Shipping with Claude Code and Codex Without Shipping Slop

AI coding tools are a real multiplier, and an equally real way to fill a codebase with unreviewed mediocrity. The habits that keep the speed and skip the mess.

I use AI coding tools daily, and they have genuinely changed how fast I ship. But the difference between teams that get a multiplier and teams that get a mess is not the tool. It is whether the human still owns the code. "AI slop" is what happens when generation speed outruns review capacity; every practice below exists to keep those two in balance.

You review it, you own it

The non-negotiable rule: nothing generated gets committed unread. Review AI output the way you review a pull request from a fast, overconfident junior: line by line, asking why, deleting what you cannot defend. If you cannot explain a generated function in a code review, it does not go in. The tool wrote it, but your name is on the commit.

Give the agent context, or it will guess

Agentic tools read your repo, so tell them how the repo works. A CLAUDE.md (or equivalent) with your conventions, commands, and hard constraints turns a generic code generator into something that writes code that looks like yours. Mine includes things like commit format, which directories own which concerns, and build commands that must not be run against the dev server. Every rule in that file is a correction I stopped having to repeat.

Small tasks, verified loops

• Scope requests to one reviewable change, not "build the feature". Small diffs keep review honest.
• Make the agent verify its own work: run the build, run the tests, screenshot the UI. "It compiles" is a low bar; insist on it anyway, then raise it.
• Keep commits atomic so a bad generated change reverts cleanly.
• Use the agent for the boring 70 percent (boilerplate, tests, migrations, refactors) and keep the design decisions yourself.

Where the tools shine, and where they lie

These tools are excellent at mechanical transformation with a clear spec: refactoring, test scaffolding, converting patterns across files, wiring up code that looks like existing code. They are weakest exactly where confidence stays high: unfamiliar APIs they half-remember, concurrency, security boundaries, and anything where the correct answer depends on context they were not given. Calibrate your review depth to that map, skim the migration, scrutinize the auth change.

Takeaways

• Generation is cheap; review is the bottleneck. Protect the review.
• Invest in repo-level context files; they compound.
• Demand verification (builds, tests, screenshots) as part of every task.
• Delegate the mechanical, keep the judgment.