An agent pipeline that turns a call transcript into merged code
An agent pipeline that turns a call transcript into merged code
The usual story after a planning call: an hour of talking, a dozen decisions, and all of it has to become tasks, code and a release without anything falling out along the way. I built a pipeline that carries a recorded call all the way to merged code, and I have been running it regularly since — it is a working process, not a one-off experiment.
How a run works
First the transcript is parsed. Speech recognition invents names and numbers with great confidence, so there is a gate on the way in: anything the call context does not support is marked as a guess and never becomes a task. Then decomposition into tasks with dependencies between them, then test-driven implementation — test first, code to satisfy it — and finally review in several independent passes along different axes: security, correctness and performance are handled by different agents that cannot see each other’s conclusions.
What the catch rate showed
The interesting part is not the speed but the findings. Consistently more than half the tasks come back from reviewers with real defects. Among them: an open redirect, two counter races, an intersection observer leak. None of that is stylistic nitpicking — it is the kind of thing that reaches production and surfaces later.
Multi-domain review matters here. A single pass over everything degenerates into a glance: the agent notes that things “look fine” and moves on. Splitting by domain forces each pass to hunt for its own class of problems and ignore the rest.
Largest run: eighteen tasks, twelve commits, six hundred fifty-six tests. Not a record for its own sake — the input was simply a long call.
What the pipeline taught me
The main lesson is not about agents but about the seams between them: per-phase reviews do not see the holes that open up between tasks. A final pass over the whole diff catches what every individual stage considered somebody else’s responsibility — and that is exactly where the expensive mistakes live.
The second lesson: a green test proves nothing until you have seen it go red. A test that passes against a broken implementation is a defect, not coverage.