Most developers use AI coding tools the way they'd use a vending machine: put in a prompt, take what comes out, shake it when it fails. I use Claude the way I'd use a strong new engineer on the team — and the difference in output is not subtle.
Here's the actual setup, with the reasoning behind it.
The repository carries the briefing
Every serious project I work on has context files in the repo: what the project is, how the architecture hangs together, what the standards are, and which decisions are settled versus still open.
That's not bureaucracy — it's leverage. When Claude Code starts a session in a briefed repository, it doesn't ask me what the error-handling convention is or invent a fourth state-management pattern. It reads, then works the way this team works.
The rule of thumb: anything you'd tell a new hire in week one belongs in a context file. You write it once; every session afterward starts warm.
Standards become skills, not reminders
Early on I noticed I was correcting the same things repeatedly — commit message formats, how money values must be handled, what a good PR description looks like. Saying it twice means it should be automated.
So standards live in reusable instruction modules — skills — that load when relevant. The commit convention is a skill. The review checklist is a skill. Domain knowledge like "how our ledger works" is a skill. When something goes wrong twice, it becomes a skill the third time.
This inverts the usual prompting arms race. Instead of writing ever-cleverer prompts, I maintain a small library of standards that compound.
Delegation happens at task level
I don't ask Claude for lines of code. I hand it tasks with acceptance criteria: "Implement the unsubscribe endpoint. Token-based, no login required, idempotent, with tests. Follow our API error envelope."
Then — and this is the part people skip — I review the diff like a senior engineer reviewing a PR. Not skimming: reading. Claude at its best writes code that looks right, and "looks right" is exactly the failure mode reviews exist to catch.
The AI reviews before I do
Before I read a diff, Claude reviews its own work against our checklist: correctness, tests, edge cases, security surface, consistency with the codebase. It catches a meaningful share of its own mistakes, which means my review time goes to the failures that need human judgment.
For higher-stakes changes I go further — separate review passes with separate concerns, one of which exists purely to try to refute the work. Agreement is cheap; survival under attack means something.
What stays human
Architecture choices with long shadows. Anything touching money until it has passed every gate. Product judgment — what to build, what "good" feels like. And the final read on everything that ships.
The honest summary: Claude hasn't replaced my engineering. It has replaced my typing, a lot of my searching, and most of my boilerplate — and it has made my standards more important, because they're now enforced by something that never gets tired of following them.
Start there: brief one repository properly, delegate one real task, review it like you mean it. The compounding starts immediately.