"AI is going to write all the code" is both overhyped and underhyped. Overhyped because it does not replace engineering judgment. Underhyped because, used well, it genuinely multiplies what a senior engineer can ship. This post is how we actually use it, and how to bring it to a team without the wheels coming off.
Where it is genuinely strong
- Mechanical breadth. Boilerplate, cross-file refactors, test scaffolding, migrations: tedious work that is not hard.
- Exploration. Spiking three approaches quickly to see which one feels right, instead of committing to one on a hunch.
- Staying in flow. Offloading the lookup-and-type loop so the engineer keeps thinking about the problem rather than the syntax.
A senior engineer with agent tooling (Claude Code, Codex, Cursor) ships more, not because they type faster, but because the boring sixty percent gets compressed and their attention goes to the forty percent that needs it.
Where human judgment still wins
The agent does not know what should not be built, which trade-off fits your business, or where the bodies are buried in your codebase. It will happily produce plausible code that is subtly wrong, or solve the wrong problem efficiently. So the discipline has not changed.
Figure 1. Generation is fast; merging is not. The review bar does not drop. If anything, agent-driven development makes review more important, because volume goes up.
A simple split of responsibility
| The agent is good at | The engineer owns |
|---|---|
| Boilerplate and refactors | Architecture and trade-offs |
| Test scaffolding | What is worth building |
| Exploring options | The final design decision |
| Mechanical breadth | Accountability for correctness |
How to adopt it on a team
Most teams either ban these tools out of fear or adopt them with no guardrails and ship a mess. The middle path is straightforward:
- Set conventions. What the tools may touch, how generated code is reviewed, and where they fit in the workflow.
- Tune them to your codebase. The difference between useful and noise is mostly context: project rules, examples, and the right files in scope.
- Keep review discipline. The bar for merging does not move. If anything it gets clearer.
- Measure the real win. It is throughput on the boring work and faster iteration, not lines of code produced.
Agent-driven development is leverage, and leverage cuts both ways. With senior review and the right guardrails, a small team punches well above its weight. Without them, it is a fast way to generate technical debt.
The bottom line
We lean hard into agent-driven development ourselves, and we help teams adopt it the same way, with the quality bar intact. The goal is not to replace engineers. It is to let good engineers spend their judgment where it counts and hand the rote work to a tool that is genuinely good at it.
If your team is trying to adopt these tools without losing control of quality, that is a problem with known answers. We are happy to share what works.