Every developer on our team uses an AI coding assistant daily. We also spend real hours each week cleaning up after them. Both things are true, and the gap between teams that benefit and teams that regret it comes down to a handful of working rules rather than the tool.
Where they genuinely help
Boilerplate and glue: data models, API clients, form handling, configuration. Tests for code that already exists, especially the tedious edge cases nobody wants to write. Explaining unfamiliar code and legacy systems. Migrations between similar libraries or syntax versions. Drafting documentation from code. In these tasks a developer who knows what good looks like moves two to three times faster and the quality is fine.
Where they hurt
Architecture and data modelling, where a plausible-looking design can lock in problems that take months to surface. Security-sensitive code, where generated examples are often outdated or subtly wrong. Anything the developer does not understand well enough to review, because the assistant is confident whether or not it is right. And large "write the whole feature" prompts, which produce code that works in the demo and nowhere else. The pattern is simple: assistants amplify judgement; they do not replace it.
The hidden cost: review load
Generated code arrives faster than it can be reviewed. If your team's bottleneck was writing code, assistants help. If it was review and testing, assistants make it worse, because pull requests get bigger and more frequent while reviewer time stays the same. Several teams we work with saw throughput fall before it rose, until they changed how they reviewed.
Rules that work
Small pull requests, no exceptions; a 1,500-line generated PR is unreviewable. The author must be able to explain every line; "the assistant wrote it" is not an answer in review. Tests are written or at least read by a human. Security, auth and payment code gets a second reviewer regardless of who or what wrote it. And the team keeps a shared file of project conventions that the assistant is pointed at, so generated code matches the codebase instead of generic examples.
Juniors and the learning problem
The biggest long-term risk is not bad code; it is developers who never build the understanding needed to review it. We pair juniors with assistants in a specific way: write it yourself first, then ask the assistant to critique it, rather than generating first and reading after. It is slower in week one and faster by month three, and it produces engineers who can still work when the tool is wrong.
What to measure
Not lines of code. Track cycle time from ticket to production, change failure rate, and time spent in review. If the first drops while the other two hold steady, the assistant is paying for itself. If failures or review time climb, your rules need tightening before your budget needs raising.
Takeaway
AI coding assistants are the best productivity tool in a decade for developers who already know what they are doing, and a liability for teams that let them replace understanding. Keep PRs small, keep humans accountable for every line, protect the sensitive code paths, and teach juniors to think first. Do that and the gains are real and durable.
