Zum Inhalt springen

Your Coding Agent Doesn’t Need Smaller Tickets. It Needs Proof of Done.

Dieser Artikel ist auf Englisch.

Fitting work into a sprint stopped mattering. The proof you can check now decides how big a ticket should be.

I have a rule for Jira stories. Nothing above 8 points. A 13 isn’t an estimate to me. It’s a confession that we haven’t understood the work yet, so we split until every piece lands between 1 and 8. The rule exists so one engineer can finish one story inside a sprint.

These days I hand those stories to a coding agent that runs against our tests and linting rules. They come back implemented and tested, usually within minutes, a few hours at worst. A 5-pointer I’d have planned two to five days for is sometimes done before my next meeting ends.

So why am I still cutting epics into 8-point pieces? I could hand the agent the whole epic and let an orchestrator run for days. Then a pull request lands that nobody on my team will read line by line.

Breaking an epic into stories was doing three jobs. It fit work to a person. It forced decisions nobody had made yet. It defined done in pieces small enough to review. Agents killed the first job and pushed the second into the spec. The third got bigger. What matters most in a ticket now is the proof that would convince you the work is finished.

Thin tickets make your agent worse

My planning ladder, from milestones of six to eighteen weeks down to 1-to-8-point stories, is priced in a person’s time. On paper a point is a couple of hours. In practice a 3 lands somewhere between one and three days, a 5 between two and five, and an 8 eats one to two weeks, because the estimate includes everything a person drags along: waiting for review, context switching, the Thursday where nothing moves because production is on fire. An agent carries none of that, and with an orchestrator fanning work out to subagents it doesn’t even need me to plan the parallelism.

Keeping the old slicing habit isn’t neutral, though. It actively hurts. Every tightly scoped ticket starts a fresh session that has to rebuild context. It reads the codebase, finds the conventions, rediscovers the domain. Feed an agent one thin slice at a time and it only ever sees one slice. It makes locally sensible decisions with no view of the whole shape. Eight tickets, eight sessions, eight slightly different opinions on error handling. That’s a design problem I created by being tidy.

There’s a cost on my side too. If the agent needs twenty minutes to implement a story and I need thirty to write that story well, the ticket is the slowest step. I’ve become the bottleneck in my own pipeline, and I’m spending that time producing a format whose main purpose was helping a human plan their week.

The thinking moves into the epic

So hand over the whole epic? That’s the tempting move, and it has a trap in it.

Breaking an epic down is where I find out we never decided how retries work, or that the migration needs a backfill, or that two „simple“ stories share a data model nobody has designed. The tickets are the output. The thinking is the point. Skip the breakdown and you skip the thinking it forced on you. The unmade decisions don’t go away. The agent makes them, quietly, somewhere around hour fourteen of the run, and you find out when you look at the result.

The thinking has to move into the epic. The epic stops being a title, two lines of description, and a list of child tickets. It becomes a spec that records the decisions already made, the ones left open on purpose, and what’s out of scope. Every acceptance criterion names the evidence that will prove it. A slice of one, for a made-up team invite feature:

## Epic: team invites (spec excerpt)

Decided: invites expire after 7 days. Links are single-use.
Open: whether admins can resend. Ask, don't guess.
Out of scope: SSO-provisioned members.

Acceptance criteria, each with its proof:
- Invited user receives an email -> integration test against a mail container
- Expired invite shows an error page -> Playwright trace + screenshot
- Member list has no N+1 queries -> query log from the preview env
- Migration is reversible -> migrate down/up on a prod-sized snapshot

Doesn’t that put me right back at the keyboard, writing? Partly. But I write the spec once instead of eight times, and every line of it gets reused. The decisions steer the whole run. The criteria become the checklist the proof has to answer at the end.

And the breakdown itself? Let the orchestrator propose it, and review the plan instead of writing it. Reading a plan is much cheaper than writing one, and it’s the cheapest moment to catch the agent misunderstanding you. Every hour after that, the misunderstanding gets more expensive.

Review the proof, not the diff

A story used to be a review boundary in a Jira costume. A few acceptance criteria produced a small pull request, which a reviewer could actually read.

You know the old joke. Ten comments on a 10-line pull request, zero on a 1,000-line one. A multi-day agent run produces the 1,000-line one, several times over. If your quality gate is „a human reviews the diff,“ then bigger tickets quietly mean a weaker quality gate.

An agent that runs for days is only useful if it knows when it’s finished. I don’t mean „wrote some code and stopped.“ I mean every acceptance criterion is met and it can show you. So the thing we review has to change. Less code, more proof. The agent attaches evidence to the ticket, one row per criterion from the spec, and I review the evidence. For the invite feature, that looks something like this:

## Proof of done

| Acceptance criterion                     | Evidence                                                        |
|------------------------------------------|-----------------------------------------------------------------|
| Invited user receives an email           | `test_invite_sends_email` passes against a Mailpit container   |
| Expired invite shows an error page       | Playwright trace + screenshot `expired-invite.png`              |
| Member list doesn't do N+1 queries       | Query log from preview env: 3 queries for 50 members            |
| Migration is reversible                  | `migrate down` then `migrate up` output on a prod-sized snapshot |

CI produces some of that. The agent produces the rest. If the evidence is thin, the work isn’t done, no matter how many checkmarks are green.

Deleting a failing test is the oldest trick in the agent playbook, and the proof is only as honest as the checks behind it. That’s why the proof contract lives in the spec, written before the run starts, and the agent doesn’t get to edit the checks that judge it. A student shouldn’t grade their own exam, and a student who can rewrite the exam definitely shouldn’t.

Proof has a limit, too. Evidence shows the feature behaves. It doesn’t show the code is something your team wants to own in a year. A green Playwright trace says nothing about whether the agent invented a fourth way to handle errors. Automated guardrails catch some of that. The rest is me reading the parts where a mistake costs money.

Size tickets by how far you can verify them

If proof is the gate, ticket size follows from it. A ticket should be the largest chunk of work whose „done“ I can confirm from evidence I’d trust without reading every line. That rule produces a breakdown that looks nothing like a uniform pile of 3s and 5s.

The invite feature, in a codebase with good tests and a working preview environment? The whole epic can be one unit of work. Billing, auth, a risky data migration? Keep those small, because the evidence I demand there includes me reading the code, and my reading speed hasn’t improved one bit.

Story points change meaning along the way. If a 3 and an 8 both come back the same afternoon, the number stopped telling me about effort. What’s left is the uncertainty, which was probably the useful part of the estimate all along, and it’s exactly what should still make you slice small. When requirements are foggy, a long run just encodes your confusion faster. Same when the work crosses teams that need to agree on an interface first.

All of this assumes you’ve done the engineering that lets an agent succeed: a validation loop it can run on its own, linting rules that enforce the code you actually want, and instructions that describe how your team builds software. The better those guardrails, the bigger the ticket you can trust. Without them, handing over an epic doesn’t give you a feature in three days. It gives you three days of confident mess.

That’s the trade nobody mentions when they celebrate killing the backlog. The time I stop spending on writing eight stories doesn’t disappear. It moves upstream into guardrails, and the guardrails pay off on every run after that, which the stories never did.

Checkpoints are the new stories

Even a well-guarded run drifts. A checkpoint where the orchestrator stops and shows proof for a subset of criteria costs far less than finding out on day three that it went sideways on day one. I let the orchestrator propose those checkpoints and review them the same way I review its plan.

Look closely at those checkpoints and they resemble stories. The difference is that the agent wrote them, and each one is defined by evidence rather than hours. My 8-point rule survives, sort of. It stopped measuring a person’s week and started measuring how much proof I can check in one sitting.

What would I need to see to believe it?

I don’t know yet which way of working wins. I do know the question I ask of a ticket already changed. It used to be „can one engineer finish this in a sprint?“ Now it’s „if an agent came back tomorrow and said this is done, what would I need to see to believe it?“

It’s the same test as the 13-point confession, measured in evidence instead of days. If I can’t answer it, the ticket isn’t too big or too small. It just isn’t ready.

How are you sizing work for agents right now? Still slicing everything to 8 points, or handing over the whole epic and waiting for proof?

DSGVO Cookie Consent mit Real Cookie Banner