AI · · 7 min read

AI coding agents on a real team: what actually changes.

The code arrives faster than anyone can read it. That moves the bottleneck, and the job, somewhere new. A practical account of what to change in review, testing and responsibility.

By Precision Code Studios, Engineering team

For most of the history of software, the slow part was writing the code. Tools, languages and methods were all, in the end, attempts to make typing the right thing faster. AI coding agents have removed that constraint almost overnight. An agent can produce in an afternoon what a developer would have written in a week.

Teams that stop there are disappointed. They generate more code, their review queues overflow, quality slips and the promised speed never reaches the customer. The agents did their part. The team's process was still designed for a world where writing was the bottleneck.

The bottleneck moves to judgement

When code is cheap, what becomes scarce is the ability to decide what should be built and to tell whether what came back is right. Those are the two points where human attention now matters most, and they sit at opposite ends of the work.

Five steps from describing a change to merging it, with the two human steps highlighted
The work in between is increasingly done by agents and automation.

What changes in practice

  • Intent has to be written down. An agent builds exactly what it is asked for. Vague requests produce confident, plausible, wrong software.
  • Tests become the specification. The clearest way to tell an agent what correct means is a test that fails until it is.
  • Changes must stay small. A person can review two hundred lines properly. Nobody can review five thousand. Smaller pieces, more often.
  • The rules move into the repository. Architecture decisions, conventions and standards kept as files beside the code are read by every agent in every session.
  • Machines check the mechanical things. Formatting, structure, dependency rules and security scans run automatically, so reviewers spend their attention on design.

Review is a different job now

Reviewing an agent's work is not the same as reviewing a colleague's. A colleague's mistakes follow from what they misunderstood, and you can ask them. An agent's code is usually tidy, idiomatic and well commented whether or not it is correct, so the surface tells you little. Reviewers have to look past the polish and ask harder questions. Does this solve the actual problem? What happens at the edges? What did it quietly change that it was not asked to? Is this simpler than it needs to be, or far more complicated?

Guardrails that are not optional

  • Least privilege. An agent gets access to what the task needs and nothing more. Never production credentials.
  • A sandbox. Agents run where a mistake cannot reach real systems or real data.
  • No secrets in prompts. Anything pasted into a model should be treated as having left the building.
  • Dependencies are checked. A suggested library is verified to exist, to be maintained and to be the real one.
  • A named human owns every change. The agent wrote it. A person is accountable for it.

Measure what reaches customers

Lines of code and number of changes will both rise, and neither means anything. The measures that matter are the ones that always did: how long an idea takes to reach users, how often a release causes a problem, and how quickly problems are fixed. If those are improving, the agents are helping. If only the volume is, they are generating work.

What does not change

Experience matters more, not less. Knowing which problems are worth solving, recognising a design that will hurt in a year, sensing that a clean-looking answer is wrong: none of that comes from the model. Teams of senior engineers get the most from these tools precisely because they know what good looks like. An agent multiplies the judgement of whoever is directing it. That is a strong argument for making sure the judgement is good.

Keep reading

All insights