AI and code quality

What this guide covers ​

Generating code now takes seconds. Judging whether that code is correct, fits the system and will hold up costs exactly what it always did. That gap is the subject of this cluster, because nearly every quality problem with AI code turns out to be a variant of it.

I write about this from practice. I use agents daily and they produce real work. Which is precisely why the friction stands out: output grows, review capacity does not, and everything you skip judging comes back later with interest. Speed got cheap, judgement didn't works that out through what large-scale orchestration does to your review.

Tests that prove something ​

The first reflex is obvious: have the AI write the tests too, and quality takes care of itself. Almost. Coverage only proves a line was executed, never that anyone would notice it being wrong. And a model that makes a reasoning error in the code will cheerfully make the same error again in the test. In AI generates your tests, but does it actually test? I use mutation testing to make that false confidence measurable: sabotage the code and see whether a single test goes red.

What happens to your codebase ​

Quality reaches past the individual PR. At codebase level, two patterns keep showing up. The first one you can measure: code churn, lines rewritten within two weeks because the first version was never really finished. The second is quieter: the lava layer, code nobody truly understands anymore and therefore nobody dares to touch. Both start at the same moment, when code enters the repo that no one has judged all the way down.

The bar that stays where it was ​

Which is why this cluster keeps landing on the same standard. Never ship code you don't understand: if you cannot explain a piece of code to a colleague without pointing at the AI, it does not belong in your repo. And keep your reading muscles trained, because you can't spot the bug if you didn't write the code. Debugging instinct is built from thousands of rounds of writing and reading your own work, and it evaporates faster than you expect.

None of these rules are new. They held when code was typed by hand. AI has only made them more urgent, because the volume at which you can break them has exploded. Typing speed used to be a natural cap on how much poorly understood code could land in your repo per week. That brake is gone, and nothing automatic took its place. The replacement has to come from your process, and that is exactly what the posts in this cluster try to provide.

Where this touches the workflow ​

Quality starts upstream, in how you drive an agent. A proper spec, small steps and review as a fixed gate prevent more misery than any linter. The hinge between those two worlds is the spec you didn't read: letting an agent write your spec is fine, forwarding it unread to a second agent is asking for trouble. The full working method lives in the agentic coding guide, under related topics below.

Below are three starting points, then every post in this cluster, newest first.