I Tested 100 Claude Secret Codes. Only 5 Actually Changed the Output.

The short answer

I ran 120 Claude "secret codes" through a controlled test over three months. About 70% of them do nothing beyond changing formatting. Roughly 5 shift the actual reasoning in a way you can measure. The rest sit in a middle ground where the output feels different but is not clearly better.

This post is the honest verdict. If you want the deeper testing data (before and after outputs, the exact test prompts, which codes stack well), that lives in the Cheat Sheet.

What these codes actually are

A "secret code" is a prompt prefix you type at the start of your message. Two shapes:

Slash codes like /ghost, /deepthink, /skeptic
UPPERCASE codes like BEASTMODE, PARETO, ULTRATHINK

They are NOT Claude Code CLI commands. They are text prefixes for Claude.ai (web, desktop, mobile). Type them and your question on the same line, send, and the reasoning behind Claude's response shifts.

Why most codes do nothing

Most codes are community-invented on Reddit and X. The prefix becomes popular, gets copied around, and eventually Claude picks up the pattern from training data. But "the model has seen the prefix" is not the same as "the prefix changes the answer."

When I tested each code by running the same prompt with and without the prefix, most of them produced output that was:

Slightly reformatted (bullets instead of paragraphs)
Slightly longer or shorter
Slightly more or less hedged

That is formatting drift, not reasoning shift. If you cannot tell the outputs apart in a blind read, the code is a placebo.

The 5 that actually work (measured)

On 14 test questions where the obvious answer was wrong (bad framing, wrong premise, weak assumption), only these five caught the mistake more often than baseline:

/skeptic: challenges the premise of your question before answering. Caught the wrong premise in 11 of 14 test cases (79%). Baseline caught it in 2 of 14 (14%). By a large margin the highest-signal code I tested.
ULTRATHINK: pushes Claude to think longer before answering. Caught wrong premises in 8 of 14 (57%). Not as sharp as /skeptic but easier to combine with other codes.
L99: anchors output at maximum depth. Best on technical decisions where the answer needs more than the obvious first pass. Improved answer quality on 9 of 14 architecture and codebase questions.
/blindspots: lists what you did not think to ask. Different mechanism from /skeptic, catches missing considerations rather than wrong premises.
PERSONA: <expert>: actually shifts vocabulary and reasoning patterns, not just tone. Named expert matters. Vague personas ("a senior engineer") do less than specific ones ("a Google SRE with 10 years on distributed systems").

Everything else on the list below is real, works consistently for the mechanical thing it does, but does not change the reasoning path. Use them for output shape, not for output quality.

The full 120 (grouped, honest labels)

Writing and style (10 codes, mostly reformatting)

/ghost: Strips AI tells, formats as continuous prose
/mirror: Matches a writing sample you paste
/raw: Strips formatting, plain response
/voice: Locks a tone for the conversation
/punch: Shorter sentences
/flow: Smoother transitions
/trim: Removes filler
/hook: Rewrites the opening line
/rephrase: Same meaning, different words
/polish: Formal tone pass

Thinking and reasoning (10 codes, the 5 real ones live here)

OODA: Observe, orient, decide, act structure
/deepthink: Longer reasoning trace (light signal)
L99: Depth anchor (real signal)
CHAINLOGIC: Shows each step
/blindspots: Missed considerations (real signal)
OVERTHINK: Deliberate over-analysis
/unpack: Breaks ideas into parts
INVERT: Backward reasoning
/layered: Surface, mid, expert levels
XRAY: Beyond obvious answers

Coding and technical (10 codes, mostly formatting)

/debug: Bug finder frame
REFACTOR: Clean up frame
/shipit: Add error handling and edge cases
ARCHITECT: Design before code
/convert: Language port
AUTOMATE: Manual to script
/testit: Test writer frame
SCAFFOLD: Project structure
/optimize: Perf focus
APIBUILD: Endpoints from English

Power commands (10 codes, mixed)

/godmode: Marketing name for longer output
/autoprompt: Rough idea to structured prompt
MEGAPROMPT: Same as autoprompt
/chain: Multi-step sequence
/system: Custom system prompt writer
PERSONA: Expert voice (real signal if the expert is specific)
/memory: Session-scoped memory
CONTEXT: Background loader
/rolelock: Character lock
PROMPTFIX: Bad prompt rewriter

Hidden modes (10 codes, mostly persona-flavored)

/nofilter: Reduces hedging
BEASTMODE: Maximum effort marketing name
/therapist: Therapy conversation frame
CEOMODE: Business decision frame
/negotiate: Negotiation script writer
FOUNDER: Founder advice frame
/closer: Sales copy frame
OPERATOR: Multi-step task runner
/unlocked: Reduces caution language
SENTINEL: Error and risk review

The remaining 70 codes fall into the same buckets and are catalogued in the Cheat Sheet. They are real codes that produce consistent formatting output. They just do not shift the reasoning.

When to actually use codes

The practical framing that came out of the testing:

Real signal codes (/skeptic, ULTRATHINK, L99, /blindspots, PERSONA:) are worth typing on any decision where the answer matters and where being wrong has a cost. Founder decisions, architecture calls, hiring, contracts, product strategy.
Formatting codes are worth typing when you have a specific output shape in mind. Writing an email in a specific tone, converting code between languages, extracting structured data. Not worth typing when you just want a good answer.
Combos matter more than individual codes. /skeptic + PERSONA: <domain expert> on a decision question consistently beats either alone. That combo pattern is where most of the real value lives, and it is what the Cheat Sheet documents.

The one code to try first

If you only try one thing from this list, try /skeptic on a question you have already decided the answer to. Something like:

/skeptic Should I switch our stack from Postgres to Mongo for the new product?

If your framing is wrong, Claude will tell you before answering. If your framing is right, you get a short "yes, and here is why" and lose nothing. That is the whole test.

Where the rest of this lives

This post covers the 120 codes at a high level. The Cheat Sheet is where the real testing data lives: before and after outputs on each code that showed a signal, the exact test prompts I ran, which codes stack with each other, and 10 workflow playbooks for common decisions. $15 for Full, $35 for Pro with the verified-test analysis. The Pro tier is the one that includes the placebo verdicts on the codes I dropped.

If you want to browse the codes first without paying, the free 75-page Claude guide has a reference card for the top 30: clskillshub.com/guide