One average obtain on the coding agents that I see goes item akin this: “Sure, AI helps you output additional code, but won’t the norm suffer?”
It certainly volition if you fair blindly merge the PRs and dispatch them off to prod. But if you obtain a thoughtful, layered method to managing quality, I discover that it’s imaginable to not fair keep the figure of bugs stable but really decrease it—while motionless expanding the output by 2-2x.
Many of these protective layers are beautiful much the identical as before Claude/Copilot/Codex/etc. (though they’re made easier now by AI), during others are new. Here’s a protective setup that I’ve seen successfully used in practice, the two on my squad and elsewhere.
One of the biggest surprises following I started using spec-driven development was the autumn in bugs in the freshly written code. Before spec-driven development, whenever building, e.g., a new feature, the teams I was on frequently spent up to a third of the total attempt on the post-development “polishing,” i.e., discovering and fixing assorted bugs. Many of these bugs occurred either since we didn’t foresee certain interactions and border cases, or since the developer was tired that day and didn’t put in adequate thought, or since the decorator or PM didn’t think through certain scenarios. Some of these bugs were missed and ended up in production.
After I started using spec-driven development, the figure of these bugs in my code sharply dropped, and I’ve seen the identical autumn for several (but not all) of my teammates. As far as I can tell, the chief logic of this autumn is one particular stage in the process: having the AI assessment the requirements or the tech scheme and discover any gaps, border cases, unexpected interactions alongside the existing code, or another akin problems.
The AI doesn’t get tired and, whenever prompted right, is a lot small apt to provision up hunting for possible issues. If anything, it can sometimes be overzealous, and I have to carefully assessment its projected edits to the requirements to create certain that it doesn’t invent any issues that aren’t there.
Coding agents now create test-driven betterment (TDD) trivial to the item anywhere there’s no logic not to do it. However, it needs to be done right: you don’t desire the delegate to blindly compose passing tests for any bugs it fair added to the code. So the finest preparedness and implementation skills I’ve seen normally prosecute this pattern:
Instruct the delegate to think through the test scenarios and test cases according to the requirements,
Write the test cases,
Write the implementation,
Test the implementation against the test cases and fix any issues that arrive up,
Maybe backfill any remaining safety gaps—but again, keeping the requirements in mind.
Also, alongside the agents penning the tests, there’s no excuse not to fire for near-universal safety or to delay on backfilling any missing component tests.
There’s motionless no substitute for a individual (you, QA, PM, or person else) really trying out the feature, going through all the border cases, and seeing whether everything plant as expected or whether you need to create changes.
These manual tests can obtain a while, particularly if the test scenarios obtain several attempt to set up. This is among the steps that so far has seen lone humble gains in productivity, and it’s the chief logic that my output has risen lone 2-3x alternatively of item akin 10x. Though now that I think concerning it, there may be a few opportunities for automation current that I’ve missed.
End-to-end (E2E) tests are arguably the most crucial tests in the codebase since they verify that new changes haven’t damaged any existing functionality as informed by the end user. Ideally, they’d run on the PRs, in the test/stage environments, and in manufacturing following all deployment. Ideally, they’d additionally be maintained by the identical developers who compose regular code, but I comprehend that several organizations aren’t really set up for that.
AI does create it easier to compose E2E tests, but to do that effectively, it needs admission to the tools or MCP servers that let it debug test failures—e.g., a browser tool or MCP admission to the logs. However, it’s crucial to keep in intellect that E2E tests aren’t a substitute for manual evaluation since they’re fair a rough, incomplete inspect that nothing crucial broke.
I discover that coding agents aren’t awesome at following complex instructions in AGENTS.md or CLAUDE.md. But they do beautiful fine if you add a distinct continue to discover and fix particular issues. These can be:
Security issues,
Finding overcomplicated or duplicated code,
Compliance alongside naming, document organization, or formatting rules,
A broad code assessment continue to discover any issues alongside the logic,
Overly lengthy comments written in AI-ese alternatively of regular English,
Any another particular things that you’d akin to discover and fix.
If added to the preparedness or implementation skills, these can be beautiful much “free” additions, adding perchance 5-15 min to the implementation period alongside no additional notice required.
They can be additionally added to the PR reviews if you favor to obtain a appearance at the comments before applying any fixes.
I think I’m becoming convinced that for insignificant tweaks and uncomplicated bug fixes, individual reviews can rotate into optional. Provided that another protective layers are motionless in place.
But for complex changes, I discover that it’s motionless necessary to assessment AI-written code. I motionless regularly discover big-picture mistakes, missed adverse interactions alongside another features, overcomplicated or suboptimal implementations, and another problems. Not to citation weird term choices akin “mint” alternatively of “generate” or “stamp” alternatively of “set.”
AI code reviews have additionally been a really awesome addition. On my current team, we run the two Claude and Cursor reviews on the PRs, and surprisingly, all of them finds distinct problems. You can additionally add another tradition reviews from assorted angles, akin security, efficiency, interactions alongside another repos, and so on, although be conscious that AI can be overly nitpicky in its reviews, so it’s crucial to additionally have a continue anywhere another delegate prunes the projected AI-generated PR comments that aren’t really meaningful.
Once the code is in production, at a minimum, it’s fine to have person periodically scroll through the logs or observe any person recordings in item akin Fullstory, or assessment assorted dashboards that track error rates, latencies, and another issues.
Even improved would be an error tracking assistance akin Sentry or GCP’s Error Reporting that detects and deduplicates errors.
The finest approach, however, would be to afterward have Claude/Cursor/whatever auto-diagnose these errors, fig out the base cause, and create PRs alongside the projected fix.
I’m certain I’ve missed another crucial components of maintaining elevated quality, but the chief idea is that alongside the correct set of protective layers, the risen output doesn’t have to arrive at the disbursal of reliability. If anything, coding agents now create it cheaper to add additional and deeper checks than before: additional tests, additional assessment passes, faster assessment of manufacturing issues.
So if you’re sufficiently focused on quality, I think it’s entirely imaginable to twice the shipment speed during keeping the bugs under control. Or perchance equal reducing them.
