Once coding agents write most of the first draft, the ticket stops being a reminder for a human and becomes the actual input to the build. Our tickets weren't written for that. Here's what we changed.
A coding agent built exactly what the ticket said and it was wrong.
The ticket asked for a CSV export on an admin report. The agent produced a clean, tested CSV export of the report as it was rendered on screen - paginated, filtered to the current view, with display-formatted dates. The person who wrote the ticket wanted the full underlying dataset with ISO dates, because finance was going to load it into another system. None of that was in the ticket. It never had been. A human engineer would have asked, or would have known from the last three exports they built for the same client.
That's the pattern we kept hitting after our workflow moved to agentic coding tools. Tickets were written as reminders for people who shared context and could ask questions. Agents don't share the context and mostly don't ask. They resolve ambiguity confidently, in whatever direction the code nearby suggests.
The ticket used to be a pointer to the work. Now it's the input to the work and the quality of the output is bounded by it.
Before agents, a feature's effort roughly split into a little thinking, a lot of typing and some review. The typing was the visible part, so that's what estimates were built around.
Now the typing is close to free and the other two have grown to fill the space:
before now
┌─────────────────────┐ ┌─────────────────────┐
│ spec ██ │ │ spec ██████ │
│ build ████████ │ │ build ██ │
│ review ███ │ │ review █████ │
└─────────────────────┘ └─────────────────────┘
effort per feature (illustrative)
The engineers who got the most out of agents weren't the fastest prompters. They were the ones who'd always written good design notes - the people who'd spend twenty minutes writing down what "done" meant before touching the code. That habit used to look slow. It's now the main thing that makes the build fast.
We tried full design documents for everything and they were too heavy. We tried one-line prompts and got the CSV problem. What settled is a short template, usually half a page, that lives in the repository next to the code it describes.
Intent. One paragraph on why this exists and who uses it. This is the part that would have prevented the CSV mistake: "finance loads this into the ledger system" changes every decision downstream.
Acceptance criteria as checks. Not prose. Concrete, testable statements - ideally written as the test names themselves. The agent writes the tests first and the human reviews those before any implementation exists. Reviewing ten test names takes two minutes. Reviewing four hundred lines of code built on a misunderstanding takes an hour and ends in a rewrite.
Constraints. The things that are true about this system and not visible in the immediate code: this table is huge, this endpoint is public, this service can't take a new dependency, timestamps are always UTC.
Non-goals. What not to do. Agents are eager. Without explicit non-goals they refactor the neighbouring module, add a config option nobody asked for or "improve" an error message that three clients parse with a regex.
Context pointers. Which files, which prior pull requests, which existing pattern to copy. This is context engineering applied to a single task - curating what the agent sees rather than hoping it finds the right example.
The biggest process change was moving the main review earlier.
We now review specs the way we used to review pull requests and for anything non-trivial the spec gets a second pair of eyes before the agent starts. It sounds like bureaucracy. In practice it's the cheapest review we do, because it happens before anything has been built and it catches the expensive category of mistake - building the wrong thing well.
Code review still happens and AI-assisted review handles a lot of the mechanical layer. But the human reviewer's job has shifted. The question is less "is this code correct?" and more "does this code do what the spec says and is the spec still right?". When the answer to the second part is no, we fix the spec first and regenerate, rather than patching the code by hand until it drifts away from any written description.
Over-specifying. A spec that dictates every function signature is just code written in English and worse than either. The spec should pin down behaviour and constraints and leave the agent room on structure. If you're writing pseudocode, write the code.
Spec rot. A spec that isn't updated when the behaviour changes is worse than no spec, because the next agent run will faithfully rebuild the old behaviour. We keep specs in the repository, version them with the code and treat a behaviour change without a spec change as a review failure.
Specs as a status ritual. If the spec is written after the code to satisfy a process, it's documentation, not a spec. The test is simple: was it written before the build and did anyone read it before approving?
Assuming the spec replaces conversation. The CSV problem was a missing conversation with finance, not a missing template field. The spec is where you write down what you learned from talking to the people who'll use the thing. It isn't a substitute for talking to them.
This shift lines up with a broader pattern we've written about in the forward deployed engineer piece: the value is moving towards understanding the problem and away from typing the solution. Writing a precise spec is a skill - part product thinking, part systems design, part technical writing - and it's become the skill that best predicts how much an engineer gets out of an agent.
It also changes what we look for when hiring. We now ask candidates to write a short spec for an ambiguous feature and then critique one we wrote badly on purpose. That tells us more than a coding exercise does about how they'll work in 2026.
When agents write the first draft, the spec is the real source of the change and the code is closer to a build artefact. Treat it that way: keep specs short, put them in the repository, write acceptance criteria as tests, state the non-goals and review the spec before the build starts.
None of this is new. Good engineers always wrote down what "done" meant. The difference is that it used to be good practice and now it's the main lever on the output.