Giving AI Agents Tickets: How to Write Work an Agent Can Finish
By Sebastiaan Jansen · · 9 min read
AI agents project management works when each ticket describes a finished change that an agent can plan, implement, and hand back for review. The ticket names the repository, the outcome, the constraints, and how a human will accept the result. A chat message is only a request. An agent-ready ticket is something an agent can actually work on.
Boards were built for people who remember who owns the module and what "make it nicer" meant last quarter. A coding agent has the repository, the ticket text, and whatever tools you give it. If the ticket is thin, the agent invents the rest, and that is where bad pull requests come from.
The rules below apply whether you use Claude Code, Codex, another coding agent, or a mix. The tracker can be GitHub Issues, Jira, Linear, or a workspace built for agents.
Why AI agents project management breaks on ordinary tickets
Most tickets are reminders for someone who already knows the system: "Fix the flaky signup test." "Add export to the billing page." "Look at the Sentry error from last night." A senior engineer can finish those from memory. An agent starts from zero on every run.
The same three failures keep showing up.
The first is an outcome that is only a vibe. "Clean up the dashboard" has no done state, so the agent renames components, restyles cards, and touches files nobody asked about. Review turns into an argument about taste.
The second is scope that covers the whole repo. Without an allow-list of paths, the agent "helps" by refactoring neighboring code, and a one-line bugfix becomes a 40-file diff. Reviewers skim diffs that size, and skimmed diffs are how defects ship.
The third is acceptance that amounts to "looks good." If the ticket does not say how to prove the change, the agent aims for something that looks fine locally. Tests, empty states, and permissions get skipped because nobody wrote them down.
So the ticket is the spec. In AI agents project management, that spec has to make sense to a process that cannot tap a teammate on the shoulder. People still own priority, risk, and the merge. The Scrum Guide's Definition of Done rests on the same idea: agree in advance what "finished" includes, then put it on the ticket.
An agent can read files you point it at, search a repo, run commands you allow, and follow a written workflow. It cannot attend the client call or remember last Tuesday's Slack thread unless that fact is in the ticket or in a file it is told to read. When the actor or the surface is missing, it guesses, and it guesses confidently.
Put the missing context into text. Paste the error, the repro, or the part of the note that matters. "See Slack" fails when the agent cannot open the thread. If your setup includes an MCP server, the agent can also read tickets and team tools through a controlled catalog, but tools do not replace the spec. Claude Code for teams and Codex with GitHub issues both work better when the issue is already a plan.
Write agent-ready tickets as a short spec
Agent-ready tickets are issues an agent can implement and a human can accept without a follow-up interview. Give them all the same shape, so reviewers know where to look and empty fields stand out in triage.
| Field | What to write | What to leave out |
|---|---|---|
| Outcome | One sentence: who can do what after this ships | A list of technologies to try |
| Why | The user pain or incident, in two or three lines | A strategy essay |
| Repo and branch | Which repository, which base branch | "Wherever it lives" |
| Allowed paths | Directories or files the change may touch | "Use your judgment" |
| Out of scope | Nearby work that is tempting and forbidden | Silence, which reads as permission |
| Constraints | Tests, style, secrets, migrations, dependencies | Slogans about quality |
| Inputs | Errors, notes, screenshots, sample payloads | A link with no excerpt |
| Acceptance | Checks a reviewer can run or read | "Make sure it works" |
| Stop condition | When to halt and ask | "Do your best" |
Keep it shorter than a design doc. Long background makes models latch onto the wrong paragraph. If history matters, put five lines on the ticket and link the source.
Outcome, paths, and checks
Write down the after state. "A workspace admin can export last month's invoices as CSV from Billing, with these columns" is an outcome. "Improve billing" is not. Name the actor, the surface, and the artifact. If you are removing a failure, quote the error string or the broken step.
List the paths the agent may edit and the ones it must not touch, such as generated code, lockfiles, billing math, auth middleware, and migrations. As an illustration (not a benchmark), a copy fix might allow apps/web/app/settings/** plus the test next to it and forbid packages/billing/**. Say whether new files are allowed, because agents like to add helpers.
Put the non-negotiables in the ticket or in a rules file the agent reads first: the test command, no new dependencies, no public API changes, no secrets, no drive-by formatting, and stop if a failure sits outside the ticket.
Version-checked writes belong there too. The agent should plan against the revision it was given, and a reviewer should be able to see that the base has not moved. If the tool cannot show that, write the rule out: re-read the base branch before you commit, and stop if it moved.
Each acceptance check should take a reviewer a few minutes. It can be a command and the result you expect, a click-path, a request and its status, a negative case, or a reject rule such as edits outside the allowed paths. "QA compares the CSV to the invoice table for one known account" is a real check. "Feels faster" is not.
A worked example
Raw request, from a call note: "Signup sometimes fails on mobile Safari. Can we just fix it? Investors are clicking the link from the deck."
That note is not a ticket yet. Here is the same request written as work an agent can finish:
Title: Stop mobile Safari from losing the signup session on redirect
Outcome: A new user on mobile Safari who signs up with email and password lands on /app already signed in. Refresh keeps the session.
Why: Two calls this week described a bounce back to /login after submit, on iPhone Safari, not desktop Chrome. No stack trace was attached.
Repo: acme/app, base branch main.
Allowed paths: apps/web/app/signup/**, apps/web/lib/session.ts, apps/web/app/signup/signup.test.ts.
Out of scope: Auth provider config, marketing pages, password rules, the native app, analytics.
Constraints: Read docs/agents.md before editing. Do not add a dependency. Do not change the session cookie name. Run pnpm test apps/web/app/signup and report pass or the first failure. If the failure sits outside the allowed paths, stop.
Inputs: Pasted repro: iPhone, Safari, start at /signup, submit a new email, redirect to /login with no banner. Screenshot on the ticket: safari-signup-bounce.png.
Acceptance:
- The signup test covers the redirect and asserts the session cookie is set.
- A reviewer on mobile Safari completes those steps and stays on
/appafter refresh. - Desktop email signup still reaches
/app. - The diff stays inside the allowed paths.
Stop condition: If the cookie domain cannot be changed from the allowed files, stop and write what you found. Do not edit infrastructure.
Plan gate: Post a five-line plan and the file list. Wait for a reviewer to comment "go" before writing code.
The task is to find the cause inside the fence. Widening the fence would be a new ticket. For a feature, swap the repro for columns, filters, who may click, and what an empty month returns.
How to run the queue
Even a pile of careful tickets fails if anyone can start anything.
- Triage every ticket into a type. Bug, small change, and story are enough. A bug might move
Needs repro → Ready → In progress → In review → Done, and agents pick up onlyReadywork. - Run one agent per ticket, on one branch. Parallel runs on the same paths overwrite each other, so sequence tickets that share files.
- Let humans move the stage. The agent may propose "ready for review," but a person runs the checks. A green test suite does not make the decision.
- Review the rollover. If you reset a weekly board, write down what carries over and who accepts it. An agent will restart a half-done branch that was left in Ready.
- Build the roadmap from tickets. A theme with no tickets behind it is a wish. A theme with outcomes and checks is a queue you can forecast from.
That queue is the practical core of AI agents project management. AI project management covers what else around the board is worth automating, though ticket quality still decides whether any of it helps. AI coding agents stay useful when review is boring: the diff matches the ticket, and nobody has to reconstruct intent from a chat log.
Send a change back when the plan says three files and the diff has twelve. For anything touching auth, money, or deletion, require the command output or rerun it yourself. If a second outcome shows up, reject the extra scope. Deduplicate in triage so two agents do not get the same bug under different titles.
What sits beside the ticket
Keep a short workflow file in the repo with branch names, test commands, forbidden paths, and when to stop. Update any structure map when the structure changes. A stale map is worse than none, because the agent will trust it. Use templates that match the table so blank fields are obvious.
Limit powers the same way. Reading the repo is enough for most tickets. A misread ticket should not be able to merge to the default branch or rotate production credentials. A catalog of MCP tools is one way to see those powers in one place. The rule itself is older than any product: do not hand out an action you would not want used on a bad reading.
Falrow is one workspace built for this loop. Slack messages, client calls, and Sentry errors become tickets. Claude Code and Codex can plan from the git repository under the team's workflow rules, with version-checked writes, and meeting notes can become reviewed tickets before anyone treats them as assigned. It runs on one SQLite database you can self-host. The writing rules here still apply if you use Jira, Linear, or GitHub Issues and enforce the fields in triage. An MCP server that lets agents plan from the repo will not fix a vague outcome. It only makes a clear ticket easier to execute.
Some work stays with people: open product debates, wide refactors with no characterization tests, and checks that come down to taste with no example to copy. A human writes the decision, and the follow-up ticket covers one reviewed change.
FAQ
What is AI agents project management?
AI agents project management means turning requests into tickets a coding agent can execute under team rules, then reviewing the result before it merges. The board still tracks priority, stages, and who decides. Each ready ticket carries the outcome, the file boundaries, and the checks, because the agent does not share the team's unstated context.
What should an agent-ready ticket include?
Include the outcome, the repository and base branch, the paths the agent may change, explicit out-of-scope items, workflow constraints, the inputs it needs, and acceptance checks a human can run. Add a stop condition for anything ambiguous. If you cannot describe how you would reject the pull request, the ticket is not ready.
Should every ticket go to an agent?
No. Send work that has a clear done state and a reviewable diff. Keep open product decisions, broad redesigns, and security design with people until someone writes a narrow follow-up. Triage is where you make that call, and a healthy queue has both human-owned and agent-owned tickets.
How do you review work an agent finishes?
Start by reading the diff against the allowed paths. Then run the acceptance checks on the ticket, including the tests it named, and confirm the plan and the change describe the same outcome. If the agent widened the scope, stop and split off a new ticket. Passing tests do not replace that read. A person moves the ticket to done.