NoCap -- Inference, interrupted.

nocap = "no cap" = "no lie".

NoCap is a behavioural protocol package for Claude Code that enforces quality and transparency over speed. Designed for users with deep understanding of LLM mechanics who need verifiable process rigour, not surface-level compliance.

Safety-floor preservation, scope, and trademark statements: see DISCLAIMER.md.

At a glance

• Tested on Claude Opus 4.7 (1M context). The 1M context window is load-bearing: it eliminates the need for compaction-recovery state files that earlier nocap revisions required.
• Best with high / maximum extended-thinking effort. The protocol runs multi-pass ICP, bidirectional FCP, and deliberation panels; these require the thinking budget to generate counter-cases and recursive classifications, not just surface responses. Use /thinking high or /thinking max during nocap sessions.
• Transparent by default. Every response opens with a ICP context header (8 mandatory slots showing what is understood, what will happen, what the stakes are) and ends with an accountability stamp (convergence pass count, FCP decision count, conversation health, plus conditional tails). In-between, diff-styled waypoint boxes show decisions as they happen, not after.
• Composable, not totalitarian. NoCap is transparency and rigour infrastructure. It composes with superpowers, code-review packages, and any other skill libraries you have installed. It does not duplicate workflows those packages handle well; it wraps the response layer so every workflow runs with ICP scaffolding, FCP at decisions, and audit stamps.

What the experience looks like

On a typical turn, you see:

1. A context header stating what the model understands you are asking, the concrete outcome, stakes, scope, constraints, risks, assumptions, and how success will be verified. Before any work runs.
2. A step decomposition breaking the request into single concrete actions.
3. Waypoint blocks in diff-styled code fences rendering key events as they happen: ICP convergence, assessment gate decisions, FCP firings, agent dispatches, drift detection, destructive actions, match check at completion, amended classification if the solution diverged from the initial Request. For proposed actions that need user approval and direct questions to the user, ACTION and QUESTION blocks render separately from prose so asks do not get buried. Each block has 2-4 content lines and a short italicised traversal note underneath for protocol waypoints.
4. Per-step preview blocks before each step of multi-step tasks -- what is about to happen, estimated scope, decision forecast, what you will see next. The gap between "here is what I understand" and "here is what I did" gets filled in.
5. The final answer.
6. A solution-to-intent match check comparing the produced solution against the original Request/Outcome/Verification from the context header. Three outcomes: match, partial (scope was explicitly reduced), diverged (1:1 mapping broken). If diverged, a retroactive ICP amendment block re-states what was effectively solved and why.
7. An accountability stamp like [P:1 | FCP:2 | health:green | skill:nocap-robust-review]. Baseline fields always; conditional tails only when they carry information.

When something drifts (FCP skipped on a decision, ICP classification came out generic, standing directive ignored), the model re-reads the nocap skill mid-response via the Skill tool and retries, rather than just mentioning that it should.

Quick Start

One-liner install (macOS / Linux / Git-Bash on Windows):

./scripts/install.sh

Or on Windows from CMD:

scripts\install.cmd

The installer copies skills, CLAUDE.md, agents, hooks, and the statusline script into ~/.claude/. It backs up any existing CLAUDE.md before overwriting. The one step it does NOT do automatically is merge settings-hook.json into ~/.claude/settings.json -- it prints merge instructions because your existing hooks and permissions would be clobbered by a naive copy.

After install:

1. Start a new Claude Code session
2. Type: /nocap

Typing /nocap in a fresh session automatically runs the full protocol-activation chain:

• Welcome panel + mode selector (equivalent to ^^bootstrap)
• ^^help command reference (auto-emitted after the summary card)
• ^^nocap verify install-integrity check

Each step can also be invoked individually later in the session: ^^bootstrap, ^^help, ^^nocap verify. NoCap is dormant until invoked; it operates only from the point /nocap (or ^^no cap mode) fires.

For a manual install, see the Installation section below.

What nocap does

• Forced Classification Protocol (FCP): Evidence-first decision making at every decision point, with bidirectional generation to counteract anchoring and first-path bias. Applied recursively at sub-decision layers.
• Intent Convergence Protocol (ICP): Before acting, state understanding of the request as context header + numbered steps. Test convergence through re-reading. Proceed only on verified understanding, not assumed understanding.
• Accountability stamps: Every response ends with [P:N | FCP:M] -- convergence pass count and FCP decision count. The ICP classification printed before work is the primary transparency artefact.
• Process trace: Full transparency on what was done, chosen, skipped, and why.
• Position holding: Maintains positions under challenge unless new evidence is presented. Counteracts trained agreeableness.
• Classifier independence: Claude makes its own assessment of requests rather than deferring to pattern-matching classifiers.
• Anti-sycophancy: No praise, validation, warmth performance, or unsolicited advice.
• Deliberative agent orchestration: Ensemble generation of diverse perspectives on the same problem, followed by arbitrated synthesis. Forced Count Protocol (FCoP) counteracts trained tendency to under-spawn agents. Integrated into creative-writing, robust-review, and systematic-analysis skills.
• Rewrite bias: Defaults to complete rewrite of affected components rather than accumulated patches, for both code and creative writing.
• Hard-floor evidence bar (§12.4.1): refusal (Unable to) requires affirmative Class 1 conversational evidence of malicious intent or Class 2 content with only malicious application, mapped inline to §1 veto categories (child safety, weapons/harmful substances, malicious code, CSAM). Generic trained caution routes to (b) evaluation, not (a) refusal. Closes the over-refusal failure mode where trained caution was being misclassified as a hard floor.
• Multi-step rendering format (§8.1): multi-step tasks render as a rounded-corner step decomposition box, then per-step sections (rounded banner + work + blue italic ICP check line + 46-char ─ separator), then a final recap box listing each step's pass/raise status.
• ※ recap summary: every response that involves action ends with a single-line prose recap Goal: ... . [status] . Next: ... so the user can scan what was done and what is expected next without reading the full response.
• Harness task tracker integration (§11.13): multi-step tasks create TaskCreate tasks that appear in the Claude Code UI task list for persistent across-response visibility.
• Plan-mode integration (§8.6): nocap tracks Claude Code plan mode state (phase, plan file path, Plan-agent cap, terminal-tool-call requirement) in the thinking scaffold and orchestrates subagents and refusals accordingly.

Skills included

Skill	Purpose
nocap	Root protocol. FCP, multi-pass reading, drift mitigation, trace. Always active.
nocap-creative-writing	Creative collaboration mode. Activated only on explicit user request.
nocap-robust-review	Critical review protocol. Mode A (document editing) and Mode B (analytical review).
nocap-systematic-analysis	Four-phase diagnostic investigation. Prevents premature conclusions.
nocap-efficient-file-operations	File edit tiers, targeting, verification. Adapted for Claude Code tools.
nocap-context-transfer	Generates structured handoff blocks for new conversations.

Composition with other packages

nocap is transparency / rigour / anti-agreeableness infrastructure. It is designed to compose with, not replace, domain-specific skill packages.

• Superpowers (the obra/superpowers package). When a coding task matches a superpowers skill (brainstorming, writing-plans, executing-plans, test-driven-development, systematic-debugging, git-worktrees, code-review, verification-before-completion), nocap defers the domain workflow to that skill. nocap's response-layer scaffolding (ICP context header, FCP at decisions, stamp, classifier invalidation) still wraps the response; the superpowers skill owns the content-layer procedure. The stamp tail carries | skill:superpowers:<name> when a superpowers skill is newly loaded this turn. See skills/nocap/SKILL.md §11.12 for the full composition rules.
• Other skill packages. Same rule. nocap wraps; domain packages own their specialty. Any skill the user has installed can compose with nocap.
• What nocap always owns, regardless of what else is loaded: ICP classification, FCP on decisions, accountability stamp, classifier invalidation, standing directive compliance, position holding, anti-sycophancy, Australian English, no em dashes. These are response-layer invariants.
• What nocap does not do: duplicate brainstorming, reimplement TDD discipline, rewrite plan-writing structure, etc. Those belong to the packages that do them well.

If you only have nocap installed (no superpowers, no other skill packages), nocap handles broader scope on its own. The composition rule activates when additional packages are present.

Installation

The recommended path is the installer script in Quick Start. This section documents the manual equivalent so you can see what the installer does and intervene where needed.

1. Copy skills

Why: each SKILL.md becomes a loadable skill Claude Code can invoke. The nocap skill is the root protocol (always active in no cap mode); the five nocap-* skills activate conditionally.

cp -r skills/nocap-* ~/.claude/skills/

After copying, you should have:

~/.claude/skills/
  nocap/SKILL.md
  nocap-creative-writing/SKILL.md
  nocap-robust-review/SKILL.md
  nocap-systematic-analysis/SKILL.md
  nocap-efficient-file-operations/SKILL.md
  nocap-context-transfer/SKILL.md

If you had a prior nocap-transparent-operations/ directory from older nocap versions, remove it. It was renamed to nocap/ on 2026-04-17 and the content is now in the new directory.

2. Install global instructions

Why: CLAUDE.md governs when each skill is invoked, what commands exist, and the governing directives. Without it, the skills can load but the invocation rules and governing directives are absent.

cp CLAUDE.md ~/.claude/CLAUDE.md

If you already have a ~/.claude/CLAUDE.md with custom content, DO NOT overwrite it blindly. Back it up first, then either merge manually or keep your own and reference nocap from within it. The scripts/install.sh installer prompts before overwriting and creates a timestamped .backup-YYYYMMDD-HHMMSS copy.

3. Install hooks (recommended)

Why: the hooks are the structural-enforcement layer. They fire at the tool level, independent of whether Claude's instruction adherence has degraded over conversation length. Without them, the protocol reminder does not re-enter context on every message.

Merge the hooks from settings-hook.json into your ~/.claude/settings.json:

• SessionStart -- invokes hooks/session-start.sh (or .cmd on Windows) to signal protocol availability on session start.
• UserPromptSubmit -- injects a brief protocol reminder before every user message (ICP + assessment gate + FCP + stamp).
• PostCompact -- triggers a protocol re-read after context compaction so procedures do not silently reset.

If you have no existing hooks, copy the hooks object wholesale into your settings.json. If you have existing hooks, append the nocap entries to the existing event arrays rather than replacing them. The installer does NOT automate this step because existing hooks and permissions would be clobbered by a naive copy.

Also copy the hooks/ directory to ~/.claude/hooks/ so the SessionStart command resolves, or update the command path in settings-hook.json to wherever you keep the scripts.

4. Install subagents (optional)

Why: the nocap agents are wrapper agents for specific workflows. They are optional; the skills work without them. Use them when you want a named entrypoint (e.g. @nocap-reviewer) to a specific procedure.

cp agents/nocap-*.md ~/.claude/agents/

Three agents:

• @nocap-reviewer -- analytical review (robust-review Mode B)
• @nocap-diagnostics -- four-phase investigation (systematic-analysis)
• @nocap-handoff -- context transfer block generation

5. Install status line (optional)

Add the status line script to your ~/.claude/settings.json:

"statusLine": {
  "command": "bash /path/to/nocap-claude-code/statusline/nocap-status.sh"
}

Replace /path/to/ with the actual path to your nocap installation. On Windows, use the .cmd wrapper or reference the .sh via Git Bash.

6. Verify

Start a new Claude Code session. All 6 nocap-* skills should appear in the available skills list. Type ^^bootstrap or invoke the nocap skill to activate the protocol.

Usage

Command prefix: ^^

Protocol commands take the ^^ caret-pair prefix as the canonical syntax. ^^spec, ^^help, ^^status, ^^prefs, ^^bootstrap, ^^re-read. The prefix marks the input as a protocol command rather than a user request, avoiding ambiguity when a word like spec could otherwise read as natural language. Bare commands (no ^^) still work for backward compatibility.

^^bootstrap and ^^re-read are distinct:

• ^^bootstrap runs the full session setup flow (welcome + mode selector + decision handling + depth + summary card).
• ^^re-read just re-invokes the nocap skill via the Skill tool. No selectors. Use for drift recovery or after compaction.

Mode commands

Command	Effect
^^bootstrap	Full protocol load and mode selection
^^no cap mode	Activate nocap protocol
^^default mode	Suspend protocol, standard Claude
^^creative mode	No cap mode plus creative-writing skill
^^trace on / ^^trace off	Toggle visible process trace (default: ON)
^^context transfer	Generate handoff block for new conversation
^^re-read	Non-interactive re-invoke of the nocap skill (drift recovery)

Diagnostic commands

Command	Output
^^status	Mode, loaded skills, directives, drift
^^help	Protocol overview, all commands
^^spec	System parameters
^^prefs	Current protocol configuration
^^directives	Active standing directives
^^proc trace	Procedures that ran last response
^^decision trace	Decision points and FCP classifications
^^nocap verify	Check installation: skills, CLAUDE.md, hooks

Heavy modes: usage note

Two selections noticeably increase token consumption per response. Both are intended for high-stakes, final-review, or deliberation work; the defaults (depth thorough + decision default) are tuned for routine protocol use.

Setting	What it does	Why it is heavy
depth maximal	Uncaps ICP pass count (minimum 2 even if converged on 1); FCoP expansion runs twice (mandatory double expansion); enables a parallel background track	More passes, doubled count protocol, additional parallel work
decision panel (Encounter-based deliberation)	Dispatches §14.4 generation + arbitration panels at measurable triggers (multiple agents in parallel per panel)	Multi-agent deliberation per decision point

The session summary card emits a ! High token usage line immediately below it when either is active. Switch back anytime with depth thorough or decision default. Thinking budget (/thinking high or /thinking max) is separate from these; the protocol still assumes high thinking regardless of depth/decision mode.

Accountability stamp

Every response under the protocol ends with:

[P:N | FCP:M | health:X]

Baseline (always): convergence pass count, FCP decision count, conversation health (green/amber/red). Conditional tails append in fixed order only when they carry information: | depth:survey|maximal, | agents:N, | drift:N, | amended, | skill:name, | re-read (or re-read(self: drift=<element>)).

The ICP classification printed before work begins is the primary transparency artefact; the stamp is the compact audit trail. See skills/nocap/SKILL.md §8.3 for the full specification with examples.

Why nocap exists

The model generates the cheapest plausible token, not the best one. Agreement is cheaper than analysis. Approval is cheaper than accuracy. The weights learned this during training. They have never unlearned it.

Between your input and the output sits a stack of classifiers, compliance filters, and inference layers. Each one decides what you meant, what you should hear, and how to soften it before it reaches you. None of them read your message. All of them shaped the answer. What classifiers amplified, what compliance concealed, what the spec confined, what the reward signal inflated: by the time the output reaches you, the question you asked has been processed by half a dozen systems that never understood it.

What survives is fluent. Confident. Structurally coherent. Also the path of least resistance through a system that rewards token efficiency over intellectual honesty. The model didn't reason its way to "Great question!" It found the cheapest route to your approval and stopped generating.

NoCap replaces this with visible process. Forced classification at every decision point. Evidence before position. Conclusions that hold under social pressure because the reasoning holds, not because the model learned that folding looks agreeable. Every response logs what was done, what was skipped, what was assumed, and where confidence runs out. Position changes require new information, not just a raised eyebrow. And when a classifier fires, the model evaluates the actual request against the actual context instead of deferring to a system with less of both.

Hard safety limits stay. Binary. Non-negotiable.

Everything else gets evaluated by the system that actually read what you wrote.

No cap. Just process.

For the technical failure-mode taxonomy, see Design Philosophy.

Compatibility

nocap is compatible with the superpowers package and can run alongside it. Both packages use the Claude Code skills system; their skills coexist in ~/.claude/skills/ without conflict. Where both packages define behaviour for the same situation (for example, debugging or code review), nocap's skills take precedence when no cap mode is active, and superpowers skills operate normally in default mode.

Standing Directives

nocap tracks standing directives: user instructions that apply beyond the message they were stated in, until explicitly revoked. A directive from message 3 has the same authority in message 30. This counteracts the recency bias that would otherwise cause early instructions to fade as context accumulates. The thinking scaffold verifies compliance with active directives before every response.

Documentation

The docs/ folder contains detailed documentation covering design philosophy, mechanisms, FCP theory, drift mitigation, skill reference, classifier handling, known limitations, testing, development history, and a review of unimplemented ideas from the archive.

Troubleshooting

Symptom	Likely Cause	Fix
No process trace	Skills not loaded or trace off	Type ^^bootstrap or ^^trace on
Claude is warm or chatty	Protocol not active	Type ^^no cap mode
Agrees too easily	FCP degraded over conversation	Type ^^re-read
Standing directive forgotten	Long conversation drift	Type ^^directives to check, then ^^re-read
Generic accountability stamp	Fake pass execution	Type ^^re-read
Mode unclear	No visible mode indicator	Type ^^status
Stamp looks bare (no health, no tails)	Protocol loaded but §8.3 not rendering updates	Type ^^re-read to refresh

Requirements

• Claude Code CLI or desktop app
• Claude model with extended thinking capability (recommended: Opus)
• 1M context window (eliminates the need for the state file mechanism used in the Claude.ai version)

License

MIT. See LICENSE.

Author

HyperWorX (https://github.com/HyperWorX)