The short answer. Claude Code does not have to guess. You just have to forbid it. I run the same Claude Code as everyone, on the same plan, with five things bolted on: a CLAUDE.md that holds my rules, Context7 for real library docs, Superpowers to force a plan and tests before any code, a code review plugin that puts five reviewers on the pull request, and Codex, a second AI from OpenAI, reading every line on the way. None of it makes Claude smarter. It means nothing in my terminal gets to say done without proving it.
- CLAUDE.md is a rules file Claude Code reads automatically before every task. It is the highest value ten minutes in this guide.
- Context7 feeds Claude current docs for the libraries in your project, so it stops inventing functions.
- Superpowers forces a brainstorm, a written plan, and tests before any implementation code.
- The code review plugin runs five reviewers over your pull request and scores what they find. A second AI reads the code again on the way.
- Every plugin here is free. The only money in this setup is the two model subscriptions.
Everyone opens Claude, types build my app, and prays. That is vibes, and vibes is why the code breaks. Mine works under written rules and it is not allowed to guess.
CLAUDE.md, the rules file
Claude Code looks for a file called CLAUDE.md in your project and loads it at the start of every session. Whatever you write there sits in its head before the first line of code. Most people never create it, which means Claude works from zero context and its own defaults every single time. That is where the guessing starts.
Mine holds three kinds of things. Rules, the behavior I refuse to debate again. Commands, so it never guesses how to run the tests. And project facts, the decisions already made that it must not quietly undo. Here is an example of the kind of rules that work, write yours from the mistakes your own Claude keeps making.
# CLAUDE.md ## Rules * Never guess an API. If you are not sure a function exists, look it up before you use it. * Run the tests before you call anything done. "Should work" is not done. * Ask before adding a new dependency. The answer is usually no. * No silent fallbacks. If something fails, show me the error. Do not swallow it. * Match the style of the file you are editing, not your own preference. * Touch only the files the task needs. No refactors I did not ask for. ## Commands * Dev server: npm run dev * Tests: npm test * Types: npx tsc --noEmit ## Project notes * The API lives in src/app/api. Every route validates input before it touches the database. * Auth is a session cookie. Do not add token logic anywhere.
You can run /init and Claude will draft a first version by reading your codebase. After that you edit it like a manager writing a job description. Every time Claude does something you did not want, that becomes a new line. Every good rule in mine started as something Claude got wrong.
Context7, real docs instead of guesses
A model learns a library once, at training time, and the docs rot after that. So Claude calls a function that got renamed two versions back, or one that never existed, and it sounds completely sure while it does it. Context7 fixes that at the source. It is an MCP server that pulls the current docs for the exact libraries in your project into Claude’s context, so the API it writes against is the API that actually ships.
It lives on the official Anthropic plugin marketplace, which Claude Code already knows about, so the install is one command.
/plugin install context7@claude-plugins-official
If Claude Code ever reports that it cannot find the marketplace, add it once with /plugin marketplace add anthropics/claude-plugins-official and run the install again. That same marketplace covers Superpowers and the code review plugin further down.
After that Claude has two new tools, one to identify the library and one to fetch its docs, and it reaches for them when it hits a library question. If it ever seems to be improvising against a package, I tell it to check Context7 first, and the improvising stops.
Superpowers, plan before code
Left alone, Claude starts writing the second you stop talking. Superpowers gets in the way of that on purpose. It is a set of skills. One of them drags out what I actually asked for before anything gets built. Another turns that into numbered steps with the tests written first. A third, for when something breaks, makes Claude chase the root cause instead of slapping a patch on the first symptom it sees.
/plugin install superpowers@claude-plugins-official
The skill I lean on hardest has the least glamorous name, verification before completion. It bans Claude from saying done until it has run the commands that prove it. Evidence first, claims second. That one rule removed the most annoying sentence in AI coding, the confident “this should work now” above code that does not.
Code review, five reviewers on the pull request
The code review plugin runs when you open a pull request. It does not skim the diff once. It launches five reviewers in parallel, each with a different job: one checks the change against your CLAUDE.md, one hunts for bugs in the diff, one reads the git history of the files for context, one looks at earlier pull requests that touched them, and one checks the code against the comments already in it.
Then every issue gets a confidence score, zero to a hundred, and anything under eighty gets cut before it reaches you. The rest lands as a comment on the pull request. A normal one-pass review drowns the one real bug under thirty nitpicks. The score is what stops that.
/plugin install code-review@claude-plugins-official
Run /code-review on a pull request and you get real findings back. But it is still Claude grading Claude. It catches the mechanical misses and the broken rules. It cannot catch the bad assumption it made writing the code, because it is still making it. For that you need something that never wrote the code at all.
The second AI, every line gets read
The final gate is adversarial. OpenAI publishes a plugin that runs its Codex model inside Claude Code, and after every feature I run one command, /codex:adversarial-review. Codex did not write the code and has no stake in defending it, so it attacks. Claude defends or rewrites, they go a few rounds, and I ship whichever version neither model can still poke a hole in.
/plugin marketplace add openai/codex-plugin-cc /plugin install codex@openai-codex
I wrote the full setup up separately, every command it installs, how the review rounds actually go, and what it costs per month, in the Codex inside Claude Code guide. Short version, the plugin is free but Codex wants a ChatGPT plan to run on.
One task, all five pieces
How a single task runs
- 1The task lands. Claude reads CLAUDE.md before it does anything, so my rules are in its head before its first idea.
- 2Superpowers blocks the code. Brainstorming digs into what I actually want, then writing plans turns it into steps with tests defined up front.
- 3While it writes, Context7 feeds it the real docs for the libraries in the project, so the functions it calls exist.
- 4Before it can say done, verification runs. Tests pass on screen or the task is still open. Claims without output do not count.
- 5/codex:adversarial-review sends Codex through every line in the working tree. Claude defends or rewrites, they go a few rounds, and only the version neither can poke a hole in moves on.
- 6I open a pull request, and /code-review runs five reviewers over it, scores what they find, and comments. Only what survives all of that ships.
At no point does that loop take Claude’s word for anything. Every step hands it the real answer or makes it show the output. Whatever comes out the other end has already been argued down twice.
Where it still breaks
The limits
Rules rot. A CLAUDE.md nobody updates is a file Claude obeys straight into a wall. When the project changes, the file changes, same commit.
Claude can still drift past a rule deep into a long task. The reviews downstream catch most of it, but you are the referee, and what both models miss ships.
The loop costs time and tokens. On a throwaway script it is overkill and I skip it. On anything that touches money or users, the minutes are the entire point.
The five pieces at a glance
| Piece | What it forces | Cost |
|---|---|---|
| CLAUDE.md | Written rules read before every task | Free |
| Context7 | Real, current library docs instead of memory | Free |
| Superpowers | A plan and tests before any code | Free |
| Code review plugin | Five reviewers on every pull request | Free |
| Codex plugin | A rival model reads every line before it ships | Free plugin, needs a ChatGPT plan |
The quick questions
Do I need all five pieces?
No. Start with CLAUDE.md. It is free, it takes ten minutes, and it fixes more than any plugin. Add Context7 the first time Claude invents a function. Add the review layers when the code starts going somewhere that matters.
Where does CLAUDE.md live?
In the root of your project. Claude Code reads it automatically at the start of every session, no command needed. You can also keep a personal one at ~/.claude/CLAUDE.md that applies to every project on your machine.
Does all this slow Claude down?
Yes. A plan, tests, and two reviews add minutes to every task. Debugging code that shipped on vibes costs hours. I will take the minutes.
What does the setup cost?
The plugins are free and CLAUDE.md is a text file. Claude Code itself is twenty dollars a month, and the second AI needs a twenty dollar ChatGPT plan on top. Everything else in this guide costs nothing.
Is this a special version of Claude?
No. Same Claude Code everyone has, on the plan everyone has. The difference is written rules, real docs, and review it cannot skip. None of that needs talent, it needs setup.
The tools I test, every week
Every week I put a new AI tool through real work and send what held up, what broke, and what it cost. Nothing gated, unsubscribe in one click.
Founder of Spectrum AI Labs — testing AI tools and models, and writing up what actually ships.
More about Paras →
