Posted on November 18, 2026

The Art of Writing Tickets for AI Coding Agents

agenticai-codingpre-build-planningspec-driven-developmentticket-writing
David Odukoya
David Odukoya Founder, Zalcro

TL;DR:

  • A good coding ticket defines the outcome, not just the task. It explains what to build, what success looks like, and what must remain unchanged.
  • Acceptance criteria, scope boundaries, and dependencies matter. They give coding agents like Claude Code and Cursor clear instructions for implementing and verifying work.
  • Zalcro generates dependency-aware implementation tickets from your app's architecture, with defined deliverables and acceptance criteria. Through MCP, coding agents can retrieve those tickets and the relevant architectural context directly from Zalcro.

You hand Claude Code or Cursor a ticket that sounds perfectly reasonable. The agent writes the code, reports success, and moves on, then you discover that it changed behavior you never asked it to touch. Maybe it introduced a new dependency, rewrote an authentication flow, or implemented a feature differently from what you intended.

The agent actually followed the request as it understood it, however the ticket left too many decisions open.

Consider this instruction:

Add subscription limits so free users can only create three projects.

Where should the limit be enforced? What happens when users reach it? Do archived projects count? What about paid subscribers? An agent can make those decisions for you, or your ticket can establish them before implementation begins.

That's the art of writing a good coding ticket: defining the work clearly enough that the agent understands the expected outcome, the boundaries, and what counts as finished.

A vague ticket vs. an agent-ready ticket

Let's use the subscription-limit example.

The vague version

Title: Add subscription limits Description: Free users should only be allowed to create three projects.

This tells the agent what feature to implement, but leaves important behavior open to interpretation.

Now compare it with a structured ticket.

The agent-ready version

Title: Enforce the free-tier limit of three active projects Objective Prevent free-tier accounts from creating more than three active projects.

Context The application already supports authenticated accounts, project creation, and subscription tiers. Project creation is handled by the backend.

Deliverables

  • Enforce the free-tier project limit in the backend.
  • Return a defined error when the limit is reached.
  • Display an appropriate message in the interface.

Acceptance criteria

  1. A free-tier account can create up to three active projects.
  2. A fourth active project is rejected by the backend.
  3. Archived projects do not count toward the active-project limit.
  4. The interface displays a clear message when the limit is reached.
  5. Paid accounts retain their existing project limits.
  6. Tests cover the allowed, rejected, and archived-project scenarios.

Out of scope

  • Changing subscription prices or tiers.
  • Building a payment or upgrade flow.
  • Changing project deletion or archival behavior.
  • Redesigning the project dashboard.

Dependencies

  • Existing authentication and account-tier data.
  • Project data model and status tracking.
  • Backend project-creation functionality.

Verification Run the relevant automated tests and confirm that the limit is enforced even when project creation is attempted directly through the API.

The second ticket gives the agent a clear implementation target. It establishes the business rules, defines the boundaries, and identifies how the completed work should be tested.

The anatomy of a good AI coding ticket

A well-structured ticket answers seven questions.

Section Question it answers
Title and objective What are we trying to accomplish?
Context What already exists, and which decisions must be respected?
Deliverables What needs to be created or changed?
Acceptance criteria What observable conditions define success?
Out of scope What should the agent leave alone?
Dependencies What must be in place before work begins?
Verification How should the completed implementation be tested?

The level of detail should match the task. Fixing a typo doesn't require an elaborate specification. Implementing subscription rules across frontend and backend components deserves more structure.

Start with the outcome

A ticket titled "Fix dashboard" gives the agent little direction.

A better title is:

Show the correct monthly revenue total on the admin dashboard.

Now the expected result is explicit.

The objective should describe the desired behavior and why it matters. You can leave implementation details to the agent where appropriate, while specifying the decisions that must not be changed.

Provide relevant context

A coding agent needs to understand the part of the application it's changing. An authentication ticket, for example, might identify the chosen identity provider, existing user roles, and where authorization checks belong.

Include relevant architectural decisions, technical constraints, and references to existing functionality. This helps the agent implement the task within the established application design.

Define concrete deliverables

Deliverables describe what the task must produce. Examples include:

  • A backend endpoint.
  • An updated database migration.
  • A new user-facing workflow.
  • Automated tests.
  • Updated technical documentation.

Keep deliverables specific. "Improve the subscription system" is difficult to evaluate. "Add backend enforcement of the free-tier project limit" gives the agent a defined target.

Acceptance criteria: the most important part of the ticket

If there's one section worth spending extra time on, it's acceptance criteria.

Acceptance criteria turn a requirement into behavior that can be verified.

Compare these statements.

Weak:

Subscription limits should work correctly.

Strong:

Given a free-tier account with three active projects, when the user attempts to create a fourth, the backend rejects the request and the interface displays the project-limit message.

The second version defines the initial condition, the user action, and the expected result. That gives the agent something specific to implement and test.

Cover the scenarios that matter

Strong acceptance criteria typically address:

  • Normal behavior: What happens when someone performs the intended action?
  • Boundary conditions: What happens at the exact limit?
  • Failure behavior: How should the system respond to invalid requests or failed operations?
  • Permissions: Who is allowed to perform the action?
  • Regression protection: Which existing behaviors must continue working?

For complex behavior, the Given/When/Then format can make acceptance criteria particularly clear. For example: Given a free-tier account with two active projects and two archived projects, When the user creates a new project, Then the backend allows the request because archived projects do not count toward the limit.

You don't need this format for every criterion. A concise checklist is often sufficient. What matters is that each criterion describes an observable outcome.

GitHub's guidance for its coding agent recommends clearly scoped issues with complete acceptance criteria. Anthropic's Claude Code best practices similarly emphasize providing verification criteria and ways to confirm completed work.

Don't just tell the agent what to build. Define what done means.

Why "out of scope" matters

An out-of-scope section may be one of the most underrated parts of a coding ticket. AI coding agents can be proactive. Sometimes that's helpful. Other times, they expand the task beyond what you requested.

Suppose you ask an agent to enforce subscription limits. It might also introduce an upgrade modal, modify the pricing logic, or refactor unrelated subscription components. Those changes might make sense in a larger product roadmap, but they don't belong in this ticket. A simple boundary can prevent that scope expansion:

Do not modify subscription pricing, the checkout flow, or existing paid-tier limits.

Out-of-scope requirements help preserve existing behavior and keep the change reviewable. They also make the difference between a product decision and an implementation decision clearer. The agent can determine how to implement the requirement while respecting the limits of what it was asked to change.

One ticket should not contain the entire application

Another mistake is creating tickets that are too large. For example:

Build authentication, user profiles, subscription payments, project management, and an admin dashboard.

That's several major features, each with its own dependencies and acceptance criteria. Breaking the work into smaller tickets gives each task a defined outcome and makes verification easier. But the tickets also need to be organized in the right order.

Ticket Task Depends on
1 Establish user and account data models —
2 Implement authentication and account roles Ticket 1
3 Create projects with ownership rules Tickets 1 and 2
4 Enforce subscription-based project limits Tickets 2 and 3

Some tasks can run in parallel. Others require foundations that must be established first. This is dependency-aware implementation planning, a core part of a phased implementation plan. A well-ordered backlog gives an agent a clear sequence of work and helps ensure that later tasks build on established components.

A good ticket needs a good architecture behind it

Even a detailed ticket can leave important questions unanswered if the application architecture hasn't been established. Consider this requirement:

Implement project sharing with permissions for clients and collaborators.

The ticket may have excellent acceptance criteria, but the agent still needs to know how projects, users, and memberships are represented. Does the app already have an authorization model? Where are permissions enforced? Which components control project access?

Those are architectural decisions. An Architecture Design Document defines the application's components, relationships, and technical constraints. Implementation tickets translate those decisions into work.

The architecture defines how the system should work. The tickets define what needs to be implemented to build it. Keeping the two connected gives coding agents a consistent reference for their tasks.

How Zalcro generates agent-ready implementation tickets

Writing one detailed ticket is manageable. Turning an entire app idea into an organized backlog of implementation tickets is a much bigger job. That's where Zalcro comes in.

Zalcro is a dedicated pre-build AI app planning tool. You describe your idea through a guided requirements conversation, and Zalcro generates the application's Architecture Design Document, system diagram, and phased implementation plan. For coding agents such as Claude Code, Cursor, and Codex, Zalcro generates structured implementation tickets derived from that architecture.

Those tickets define implementation objectives, deliverables, acceptance criteria, and technical dependencies, organized into a build sequence.

Architecture → dependency-aware tickets → implementation by coding agents.

You get an implementation backlog connected to the technical decisions behind the application, without manually writing and coordinating every ticket from scratch.

Connect your tickets to coding agents through MCP

Zalcro also supports MCP (Model Context Protocol), allowing compatible coding agents to retrieve project planning information directly. With the connection configured, Claude Code or Cursor can access relevant architecture context and implementation tickets from Zalcro without requiring you to paste the same documents into every conversation.

The agent can retrieve a ticket, understand the architectural decisions behind it, and use its acceptance criteria to guide implementation and verification.

Zalcro connects the pre-build plan to the coding agents responsible for executing it.

Explore how Zalcro plans apps for AI coding agents

Frequently asked questions

What should an AI coding ticket include?

A strong ticket includes an objective, relevant context, deliverables, acceptance criteria, out-of-scope requirements, dependencies, and verification steps. Keep each section focused on the work the agent needs to perform.

Why are acceptance criteria important for AI coding agents?

Acceptance criteria describe observable behavior that the agent can implement and test. They establish a shared definition of completion and make the result easier to review.

How do I break an app into tickets for Claude Code or Cursor?

Start with the application architecture, identify technical dependencies, and divide implementation into manageable tasks. Each ticket should have a clear deliverable and acceptance criteria. Zalcro generates this dependency-aware backlog from the app's architecture.

Can AI generate implementation tickets automatically?

Yes. General-purpose AI assistants can draft tickets, while dedicated planning tools like Zalcro generate them as part of a connected application blueprint. Zalcro also provides MCP access so compatible coding agents can retrieve the tickets and their architectural context.

Your next coding task deserves more than a one-line prompt

Before handing a ticket to Claude Code, Cursor, or another coding agent, check three things:

Is the deliverable clear? Are the acceptance criteria testable? Is the scope explicitly bounded?

Then make sure the task respects the application's architecture and its dependencies. Those decisions determine what the agent is being asked to implement and how you will judge the result. Zalcro brings that structure into the planning process, generating architecture-connected implementation tickets that coding agents can access through MCP.

Give your agent a ticket with a clear definition of done—and a blueprint that explains how the work fits together.

Generate your app's implementation tickets with Zalcro

Keep Reading