How to create tickets in the AI era
How to structure tickets for teams developing software with AI agents: objectives, scope, acceptance criteria, context, tools, and practical examples.
Updated: November 14, 2026
Using AI agents in software development changes how tasks are executed, but also requires attention to how they are specified.
A ticket needs to communicate the expected result, bound the work, and point to the context needed for the developer to execute or delegate implementation to their agents.
This does not mean writing detailed instructions for every programming step. The goal is to provide enough information to guide execution, reduce misinterpretation, and allow the delivery to be evaluated.
A good ticket defines the problem, success conditions, and implementation boundaries without replacing the owner's technical decisions.
1. What needs to be clear before starting?
Before creating the ticket, it is important to define four elements:
- Problem: what needs to be resolved or modified?
- Objective: what result do we expect to achieve?
- Scope: which features, components, or behaviors are involved?
- Acceptance criteria: how will we know the delivery is correct?
This information guides both the developer and the agents used during implementation.
When a requirement allows different interpretations affecting application behavior, the uncertainty should be clarified before execution.
On the other hand, there is no need to anticipate every technical decision. The owner can investigate the project, identify the appropriate approach, and use agents to implement the solution.
2. What information should the ticket include?
Not every ticket needs every field. A simple fix can be specified in a few lines, while a feature involving several integrations requires more context.
The structure can include:
| Field | What to record |
|---|---|
| Objective | Expected result and reason for the change. |
| Context | Current behavior, affected users, and relevant information. |
| Scope and boundaries | What should change and which boundaries must be respected. |
| Acceptance criteria | Observable conditions determining whether delivery is correct. |
| References | Documentation, screens, API contracts, and related decisions. |
| Execution instructions | Specific guidance supplementing existing standards. |
| Available resources | Relevant skills, tools, MCP integrations, and environments, when necessary. |
| Dependencies | Other deliveries, decisions, or access needed. |
| Estimate | Expected effort or duration according to team practice. |
| Tests and validations | Scenarios requiring verification and tests to create or update. |
| Evidence | Results, logs, screenshots, or other information needed to evaluate delivery. |
Essential and supplementary information
Objective, relevant context, scope, and acceptance criteria form the specification's foundation.
The remaining fields are used as needed.
For example, a ticket changing an external integration may require API contract references, while a visual adjustment may need a link to the approved design.
It is also important to distinguish three concepts:
- Acceptance criteria: describe the behavior to be delivered.
- Tests: define how that behavior will be verified.
- Evidence: demonstrates which checks were performed and their results.
Estimates with AI agents
Agent usage can reduce implementation time, but does not eliminate investigation, supervision, tests, review, or adjustments.
An estimate should consider the total effort needed to deliver the result, not just the expected time to generate code.
When uncertainty is significant, an effort or time range may be more appropriate than an excessively precise estimate.
3. What should be written in the ticket and what should only be referenced?
A common mistake is repeating instructions in the ticket that should be part of permanent project documentation.
Architecture and security standards, file organization, code conventions, and general agent instructions should remain in shared project references.
The ticket should focus on the request's particulars.
Example of an unnecessary instruction:
Use TypeScript, follow project naming conventions, respect existing architecture, and run lint.
If these rules are already part of repository standards, they do not need repeating.
Example of a specific instruction:
This change must preserve compatibility with clients still using the previous API version. Consult the integration contract linked to the ticket.
The second instruction adds a relevant constraint for that delivery.
This also prevents old tickets from perpetuating outdated instructions or instructions conflicting with current standards.
Organization of these references is explored further in Context architecture, engineering, and documentation and Standardizing projects for development with AI agents.
4. How should skills, MCP integrations, and other tools be indicated?
The ticket can point to resources that help the owner and their agents execute an activity.
However, tools do not need listing simply because they are available in the project.
Ideally, resources should be indicated when a specific need exists.
| Need | Ticket guidance |
|---|---|
| Visual implementation | Consult the approved design through the Figma integration. |
| Database change | Use the project-defined migration skill. |
| Interface validation | Execute the indicated scenarios in the test environment using the automated browser. |
| External integration | Consult the current contract and API references. |
Model, IDE, CLI, or delegation strategy choice normally remains with the execution owner, respecting established standards.
Credentials and sensitive data must not be inserted directly into tickets. Service and environment access must follow project-authorized mechanisms.
These technologies are explored further in Harnesses, skills, tools, and MCP.
5. When should checklists or subtickets be used?
Checklists and subtickets help organize larger deliveries, but serve different purposes.
A checklist is useful when work has related stages that can remain under one owner and one delivery.
Subtickets make sense when certain parts need independent tracking, have different owners, or involve important dependencies.
For example, a feature may involve:
- Adapting the API contract.
- Implementing the backend.
- Updating the frontend.
- Integration tests.
- Validating the complete feature.
These activities can form a checklist or be distributed into subtickets depending on complexity and team organization.
The parent ticket should preserve the overall objective, relevant dependencies, and criteria determining when the entire feature is complete.
Detailed work division techniques are covered in Task decomposition and delegation.
6. How should uncertainties and changes during execution be handled?
Even a well-specified ticket may raise questions during implementation.
It is important to distinguish a technical decision from an undefined requirement.
The developer can decide how to organize classes, functions, or components within existing standards. However, they should not assume undefined business behavior.
When an agent identifies relevant ambiguity, the owner should assess whether it can be resolved through available references or whether the person who defined the request needs to be consulted.
Scope changes
If a decision changes expected behavior, acceptance criteria, or dependencies, it should be recorded in the ticket or linked documentation.
This keeps history accessible to those executing, reviewing, or later resuming the work.
The ticket does not need to record every agent attempt. It should preserve decisions affecting the delivery outcome.
7. What does a ticket look like in practice?
The following examples use different levels of detail. The structure can be adapted to Jira, GitHub Issues, Linear, or the team's tool.
Example 1 — New feature
Ticket: Add an availability filter to the product listing
Objective
Allow users to view only products available for purchase.
Context
The current listing displays available and unavailable products. Users need to manually identify which items can be purchased.
Scope
- Add an availability filter to the listing.
- Apply the filter together with existing filters.
- Preserve current behavior when the new filter is disabled.
Acceptance criteria
- [ ] Users can enable and disable the filter.
- [ ] With the filter enabled, the listing displays only available products.
- [ ] Other filters continue working in combination.
- [ ] The empty state is displayed when no product matches the selected filters.
References
- Current listing page.
- Product API contract.
- Approved design, if applicable.
Tests and evidence
- Check scenarios with the filter enabled and disabled.
- Validate combination with other filters.
- Present test results and visual interface evidence.
Estimate
To be defined by the owner after assessing implementation and integration points.
Example 2 — Bug fix
Ticket: Fix duplicate items when loading the next listing page
Problem
In certain situations, products already displayed appear again after the next page loads.
Steps to reproduce
- Open the product listing.
- Apply a filter.
- Load more results.
- Check displayed items after the update.
Current behavior
Some products appear more than once in the listing.
Expected behavior
Each product should appear only once, respecting the applied sorting and filters.
Scope
Investigate pagination and fix the duplication's cause while preserving existing listing behavior.
Acceptance criteria
- [ ] Navigating between pages does not display duplicate products.
- [ ] Sorting and filters continue working.
- [ ] The fix does not cause valid results to be lost.
Tests and evidence
- Reproduce the problem before the fix, when possible.
- Add or update an appropriate regression test.
- Record the result before and after the change.
Example 3 — Broad delivery with subtickets
Ticket: Implement address management in the customer account
Objective
Allow authenticated customers to create, view, edit, and remove their addresses.
Context
Currently, address information is supplied only during certain operations. The new feature will allow advance management in the account area.
Scope
- Create the necessary endpoints.
- Implement address persistence.
- Build the management interface.
- Apply validation and authorization rules.
- Integrate frontend and backend.
Dependencies
- Definition of required fields.
- API contract.
- Screen designs.
- Rules for removing or changing addresses associated with existing operations.
Suggested subtickets
| Subticket | Delivery |
|---|---|
| 1 | Address contract and persistence |
| 2 | Endpoints and authorization rules |
| 3 | Management interface |
| 4 | Integration and functional validation |
Parent ticket acceptance criteria
- [ ] Customers can create, edit, and remove addresses according to defined rules.
- [ ] Addresses are associated exclusively with the authenticated account.
- [ ] The system rejects invalid data.
- [ ] The interface displays appropriate success and error messages.
- [ ] The complete feature passes established checks.
Tests and evidence
Each subticket should present checks related to its scope. The parent ticket requires integrated feature validation.
Estimate
Defined after assessing dependencies and subtickets, including integration and final validation.
Conclusion
Tickets remain instruments for communicating needs, organizing deliveries, and tracking results.
AI agent usage makes specifying objectives, boundaries, references, and acceptance criteria even more important, because a misinterpretation can quickly become code.
This does not require excessively detailed tickets or instructions anticipating every implementation decision.
The goal is to give developers and their agents the context needed to execute work autonomously while preserving human responsibility for requirement interpretation and delivery quality.
Share this article
Sources & further reading
This note is a practical introduction, not a substitute for the original documentation. Check source dates and implementation details before making technical decisions.