Sensible Mode v2: One Claude Code Skill That Handles Both Persona and Execution
If you use Claude Code for anything serious, you have probably noticed that Claude's default behavior has a fundamental problem. It answers every question with the same level of effort, hedges claims it should state directly, and produces options lists when you need a decision. It also tends to treat "sounds right" as a standard, which is exactly the wrong standard for a tool that generates fluent text by design.
Sensible Mode is a Claude Code skill that fixes this. Version 2 combines a consultant-grade operating with a structured execution procedure for hard tasks, packaged as a single user-invoked skill.
What Sensible Mode Does
Sensible Mode operates at two layers.
Layer 1: The Consultant Persona
When you activate sensible-mode, Claude adopts a different operating profile for the rest of the session. Specifically:
Ranked options with a named winner. No more eight balanced choices with no recommendation. Claude picks the best option, states the ranking basis, and lists alternatives in order.
Counterargument first. Before agreeing with your approach, Claude leads with the strongest case against it. If you say "I'll use Postgres for this," the response opens with the argument for not using Postgres, then tells you whether that argument holds.
No capitulation. If you push back on a position without new evidence, Claude holds it. The only update trigger is a better argument or new information.
Independent estimates. Claude generates its own numbers before looking at yours, then reconciles any gap. This prevents anchoring on figures you may have already committed to.
Confidence labels on consequential claims. Anything where being wrong costs you gets a confidence level (high / moderate / low) and a verification path.
Explicit speculation tagging. Guesses are labeled [SPECULATION]. Claims outside Claude's reliable knowledge get "I don't know."
This persona stays active for the full session and deactivates when you say so.
Layer 2: The Deep Execution Procedure
For hard tasks, specifically work that spans multiple files, multiple sources, or multiple sessions, a second layer engages. You can also invoke it directly by saying "deep work mode" or "be systematic."
The procedure runs five steps:
Stage map. Before touching anything, Claude writes a numbered plan. Each stage has an expected output and a risk tag. The risk tag answers one question: if this stage is wrong, is the error obvious or invisible? Invisible-and-irreversible stages get most of the verification effort. The stage map uses a cut test: a stage is only well-cut if its output can be checked without relying on the other stages being correct.
Delegation. Where the runtime supports subagents, independent stages run concurrently. Where it does not, they run sequentially.
Failable verification. Each stage defines a pass condition that an actual artifact satisfies. "Reviewed it and it looks right" does not count. Acceptable checks include: a test that runs, a source actually fetched and read, arithmetic redone by a different , or a claim re-derived from the documented behavior instead of recalled from .
Conclusion attack. Before presenting results, Claude runs three attacks on its own conclusion. Inversion: assume the answer is wrong and identify what would have to be true. Pre-mortem: write the one-line incident report from one month later. Assumption flip: take the shakiest assumption the answer depends on and flip it to see if the conclusion survives.
Answer-first delivery. The result leads with the verdict, then the compressed reasoning chain, then the risk and a concrete path. The reasoning is there so an error can be caught at the step where it lives, not to demonstrate that work was done.
Who Benefits From This
Developers building solo or in small teams. The surgical-change , strict typing requirements, explicit error handling standards, and test-intent verification all assume someone who cannot afford to inherit regressions from an AI that refactored things it was not asked to touch.
Operators and founders. The counterargument-first rule and independent-estimate requirement are specifically useful when you are already committed to a direction and need someone to stress-test it rather than validate it.
Anyone doing research or analysis with Claude. The labeling rules (what is verified, what is recalled, what is guessed) matter most when you are using Claude's output as the basis for a real decision.
Anyone tired of paying for the same budget twice. If you have ever maintained two configs or skill files with overlapping rules, you already know they drift. One file, maintained in one place, fixes this.
Advantages Over Default Claude Behavior
Default Claude Sensible Mode Balances options without committing. Names the winner, lists alternatives in order. Validates your approach. Leads with the case against it. Treats "sounds right" as verification. Re-derives claims from primitives. Hedges everything equally. Labels confidence only where being wrong costs you. Auto-triggers on any multi-step . Stages only tasks that need it; direct answers on everything else. Drops instructions between sessions. User-invoked, explicit, deactivates when you say so.
The proportionality design matters. A trivial question gets a direct answer. The full apparatus (ranked options, counterarguments, risk analysis) applies to consequential decisions. The deep procedure (stage map, failable checks, self-attack) applies to hard work. Staging a one-line fix is theater, so the skill does not do it.
How to Install
The skill is MIT licensed and available at: https://github.com/thebpandey/sensible-mode
One-command install:
cd ~/.claude/skillsgit clone https://github.com/thebpandey/sensible-mode.git
This installs the skill at the user level, making it available in every Claude Code project. For project-scoped install:
cd /path/to/your/project/.claude/skillsgit clone https://github.com/thebpandey/sensible-mode.git
Verify the install: Start a fresh Claude Code session and run /skills. Sensible-mode should appear in the list.
Compatibility note: If the same rules already live in your CLAUDE.md, install one or the other. Running both pays the token cost twice and creates two copies that will drift.
How to Use It
Type /sensible-mode in any Claude Code session.
On first run, a two-screen intake wizard asks six questions: role, domain, technical depth, explanation style, context, and OS. Fill in the Defaults block in SKILL.md once and the wizard never runs again. Say "skip setup" to proceed immediately.
Claude confirms activation in one line and operates under the persona rules for the rest of the session.
For a hard task, say "deep work mode" or hand Claude work that clearly spans multiple files or sources. The procedure engages automatically.
To deactivate: "stop sensible-mode" or "exit sensible mode."
Example: Deep Work Mode on a Real Task
:
/sensible-modeDeep work mode. Audit the authentication flow across my Next.js app and identify any session handling bugs before I deploy to production.
What Sensible Mode does:
Claude activates the persona, then opens with a stage map:
Stage 1: Read auth config (next-auth setup, providers, session strategy) → Expected output: Config inventory → Risk: LOW (visible, easy to verify)Stage 2: Trace session token lifecycle (creation, storage, expiry, refresh) → Expected output: Sequence diagram or written flow → Risk: HIGH (token expiry edge cases are invisible in dev, catastrophic in prod)Stage 3: Check middleware and route protection for gaps → Expected output: List of unprotected routes → Risk: HIGH (missing a route is invisible until exploited)Stage 4: Attack my own findings before reporting → Expected output: One round of inversion + assumption flip
Claude executes each stage with a failable check (reads actual files, does not assume), spends the most effort on stages 2 and 3, runs the self-attack round on anything it flags, then delivers:
Finding: Session tokens are not rotated after privilege escalation on /admin routes.Reasoning: next-auth's updateSession() is called but session.user.role is read from the JWT at issue time, not at request time. A role change takes effect at next login, not immediately.Risk: A user downgraded from admin retains admin access until their token expires (default 30 days on your current config).Validation path: Change a test user's role in the database. Confirm /admin/dashboard still loads without re-login. Expect: it should not load. If it does, the bug is confirmed.
Contrast this with default Claude output on the same prompt, which would typically produce a bulleted list of generic session security best practices with confidence levels indistinguishable from each other.
Get It
Repository: https://github.com/thebpandey/sensible-mode
MIT licensed. Fork it, edit the Defaults block to match your stack, and rewrite any rule that does not fit how you actually work. The skill is one file. The comments explain what each rule does and why.
