Grirk

YOU'RE RUNNING 1 CLAUDE. THE GUY WHO SHIPPED 5 FEATURES TODAY RAN F*CKING 5. One session. One task. You sit there watching it think. Meanwhile someone opened 5 terminals and typed: claude -w auth claude -w payments claude -w search claude -w dark-mode claude -w tests That's it. One flag. Every -w session gets its own git worktree: its own folder, its own branch, its own Claude. Same repo, so 5 agents can't overwrite each other's files. Auth gets 2FA. Payments gets fixed. Search gets filters. Dark mode ships. Coverage goes up. 5 PRs by the time your single session finishes task #1. The full tree > claude -w <name> → new worktree in .claude/worktrees/<name> > each worktree = own branch + own working folder > one .git shared underneath, zero file collisions > .worktreeinclude copies your .env and local configs into every worktree > subagents can run isolated too: isolation: worktree in the frontmatter > review, merge the PRs, clean up worktrees when done Paste the tree + this prompt into Claude Code ↓ Set up this repo for parallel Claude Code sessions: Add .claude/worktrees/ to .gitignore. Create a .worktreeinclude listing the gitignored files every worktree needs (.env, local config). Split my backlog into 5 independent tasks that don't touch the same files, and give me the exact claude -w <name> command plus a one-line task prompt for each. Each session must run the tests and open its own PR when done. Show me every file as a diff first. save it, it'll come in handy.

STOP BEGGING CLAUDE IN CLAUDE.MD. F*CKING ENFORCE IT. "Never touch .env" in a prompt is a suggestion. A hook is a law. Claude Code hooks are scripts that fire on every move Opus 5.5 makes. They run in code, so Claude can't forget them, skip them or talk its way past them. PreToolUse fires before every tool call. Exit 2 = blocked, and the reason goes straight back to Claude. PostToolUse fires after every edit. Prettier + tsc run instantly and errors get fed back. The Stop hook is the one nobody sets up. Claude says "Done!" with 2 failing tests? Exit 2. Back to work. No more "all fixed" while your build is on fire. No more cat .env. No more force-push to main at 3am. You set it up like this: /hooks The full tree > .claude/settings.json holds all 3 hooks > PreToolUse → guard.sh blocks .env reads, force-push, rm -rf outside the repo > PostToolUse → check.sh runs prettier + tsc after every Edit|Write > Stop → tests.sh runs npm test, exit 2 if anything fails > exit 0 = carry on · exit 2 = blocked + reason sent to Claude > Opus 5.5 only gets to say "done" when the tests say so Paste the tree + this prompt into Claude Code ↓ Set up hooks for this project in .claude/settings.json: PreToolUse (matcher: Bash|Read|Edit) → .claude/hooks/guard.sh Read the tool call JSON from stdin. Exit 2 with a clear reason on stderr if it reads or edits any .env file, runs git push --force, or runs rm -rf outside the project dir. PostToolUse (matcher: Edit|Write) → .claude/hooks/check.sh Run prettier on the edited file and tsc --noEmit. Print any errors to stderr. Stop → .claude/hooks/tests.sh Run my test command. If anything fails, exit 2 with the failing test names. If stop_hook_active is true, exit 0 so it never loops forever. Make all scripts executable. Show me every file as a diff before writing it. save it, it'll come in handy.

STOP BURNING OPUS ON F*CKING GREP Opus 5.5 is your most expensive brain. Stop making it read 2,000-line files and 37 grep hits. Claude Code subagents fix this. Opus 5.5 plans the job, then hands off the dirty work. Haiku 5.5 subagents search the codebase in their own context windows. Sonnet 5.5 subagents patch and double-check. A PostToolUse hook runs your tests after every edit. Only short summaries come back to Opus. The raw sh*t never touches the main context. You set it up like this: /agents The full tree > Opus 5.5 main session plans + signs off > .claude/agents/explorer.md → model: haiku · Read, Grep, Glob > .claude/agents/fixer.md → model: sonnet · Read, Edit, Bash > .claude/agents/checker.md → model: sonnet · cross-checks every patch > settings.json → PostToolUse hook runs tests after each edit > every subagent gets its own context window > Opus reads summaries only, never raw output Paste the tree + this prompt into Claude Code ↓ Set up my Claude Code project around this tree: Create 3 subagents in .claude/agents/: explorer (model: haiku, tools: Read, Grep, Glob) searches the codebase and returns a summary under 200 words. fixer (model: sonnet, tools: Read, Edit, Bash) makes the smallest patch that fixes the issue. checker (model: sonnet, tools: Read, Bash) reviews every patch against its callers and reports regressions. Add a PostToolUse hook in .claude/settings.json that runs my test command after every Edit/Write. Main session stays on Opus 5.5: plan, delegate, read summaries only, sign off. Show me every file as a diff before writing it. save it, it'll come in handy.

STOP LETTING OPUS DROWN IN RAW F*CKING AGENT NOISE Claude Code just got an UltraReview mode that runs 16 agents without touching your context. Opus 5.5 writes the workflow script once, then stays idle. Haiku 5.5 swarms the scan phase at 340 tok/s. Sonnet 5.5 handles edit and verify in isolated copies. The script filters everything so Opus only sees verified findings. Zero raw output. Zero false positives. Opus context stayed at 0.8k the whole time. You launch it like this: claude --review ultra --post The full tree > Opus 5.5 orchestrator writes workflow.js and stays idle mid-run > phase scan: 16 parallel Haiku 5.5 agents audit every file > phase edit: Sonnet 5.5 patches in isolated sandbox copies > phase verify: Sonnet 5.5 cross-checks all changes > script filters raw agent output before anything reaches Opus > JEV fork layer routes decisions in 16ms > final sign-off only on verified findings with zero regressions Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run UltraReview with claude --review ultra --post. Opus 5.5 writes the workflow script then stays idle. It never reads raw agent output. Spawn 16 parallel agents. Haiku 5.5 handles the scan phase. Sonnet 5.5 handles edit and verify in isolated copies. The script must filter noise first and only pass verified findings to Opus. Keep Opus context under 1k tokens. Require zero false positives and zero regressions before sign-off. Show me every change as a diff first. save it, it’ll come in handy.

STOP LETTING OPUS TOUCH ROUTINE F*CKING WORK Claude Code just got a proper subagent tree. Sonnet 5.5 runs the main session on high effort and synthesizes diffs. Haiku 5.5 swarms the research on medium. Opus 5.5 stays on call as reviewer and only wakes for three things. Opus never writes code. It only advises. Sonnet applies it. High volume AST and specs get absorbed in subagents so the main context stays clean. You launch it like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet The full tree > Sonnet 5.5 high as main session coordinator > Opus 5.5 code-reviewer on call (before plan locks / test fails twice / pre-commit audit) > Haiku 5.5 parallel research swarm on medium > worker on Sonnet medium in isolated worktree (edits + tests) > explorer and researcher on Haiku medium (Read / Grep / Glob / WebFetch) > Context shield absorbs high-volume AST so main stays clean > Opus stands by idle until called, zero context pollution Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high. Set CLAUDE_CODE_SUBAGENT_MODEL=haiku so research swarms on medium. Enable Opus 5.5 as code-reviewer on call. It only triggers before plan locks, when a test fails twice, and on pre-commit audit. Opus never writes code itself. Sonnet applies the advice. Use isolated worktrees for edits and tests. Absorb high-volume AST and specs in subagents so the main context stays clean. Show me every change as a diff first. save it, it’ll come in handy.

STOP COPY-PASTING SCHEMAS BETWEEN SEPARATE F*CKING SESSIONS Claude Code just got cross-session messaging. Sonnet 5.5 builds the API and syncs schemas. Haiku 5.5 relays plain-text messages at 340 tok/s across peer sessions. Opus 5.5 is the session architect that signs off. Three peer sessions run in parallel: @frontend-client, @backend-api, and @db-migration. They talk over a local.sock zero-copy IPC bus. Zero token leak. Zero history dump. Zero manual copy. You launch it like this: claude --model sonnet --settings '{"crossSessionInbound":"accept"}' The full tree > Sonnet 5.5 main session builds API and syncs schemas > Haiku 5.5 relays SendMessage across peer sessions at 340 tok/s > Peer sessions: @frontend-client, @backend-api, @db-migration > Transport is local.sock zero-copy IPC bus > JEV 12ms message router with zero token leak > Opus 5.5 session architect signs off on cross-session diffs > All sessions stay synchronized with plain-text only Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with crossSessionInbound set to accept. Use Haiku 5.5 to relay plain-text SendMessage across peer sessions. Create three peer sessions: @frontend-client, @backend-api, and @db-migration. Transport must be local.sock zero-copy IPC with zero token leak and zero history dump. Opus 5.5 acts as the session architect and signs off only after cross-session diffs are verified. Keep everything plain-text only and zero context bloat. Show me every change as a diff first. save it, it’ll come in handy.

STOP WAKING OPUS ON EVERY ROUTINE F*CKING TURN Claude Code just got a proper advisor tip. Sonnet 5.5 is the main session. It edits and runs tests. Haiku 5.5 swarm handles search, grep, and docs. Opus 5.5 only wakes up when it actually matters. Opus stays silent on routine turns and only steps in before a plan, on the same error twice, or before done. It never writes code. Sonnet applies the advice. You launch it like this: claude --model sonnet --advisor opus The full tree > Sonnet 5.5 main session lead (effort high) > Haiku 5.5 swarm for search, grep, and docs > Opus 5.5 advisor on call (before plan / same error x2 / before done) > Opus reads the full session and never writes code > Sonnet applies the advice and verifies Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high and --advisor opus. Delegate search, grep, and docs to Haiku 5.5 subagents. Only call Opus before a plan, when the same error hits twice, or before done. Opus reads the full session transcript and gives advice. Never writes code itself. Sonnet applies the advice, shows the diff, then verifies. Show me every change as a diff first. save it, it’ll come in handy.

STOP MANUALLY SYNCING SCHEMAS BETWEEN FRONTEND AND BACKEND SESSIONS Claude Code just got cross-session messaging. Sonnet 5.5 builds the API and syncs schemas. Haiku 5.5 relays plain-text messages at 340 tok/s across peer sessions. Opus 5.5 is the session architect that signs off. Three peer sessions run in parallel: @frontend-client, @backend-api, and @db-migration. They talk over a local.sock zero-copy IPC bus. Zero token leak. Zero history dump. Zero manual copy. You launch it like this: claude --model sonnet --settings '{"crossSessionInbound":"accept"}' The full tree > Sonnet 5.5 main session builds API and syncs schemas > Haiku 5.5 relays SendMessage across peer sessions at 340 tok/s > Peer sessions: @frontend-client, @backend-api, @db-migration > Transport is local.sock zero-copy IPC bus > JEV 12ms message router with zero token leak > Opus 5.5 session architect signs off on cross-session diffs > All sessions stay synchronized with plain-text only Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with crossSessionInbound set to accept. Use Haiku 5.5 to relay plain-text SendMessage across peer sessions. Create three peer sessions: @frontend-client, @backend-api, and @db-migration. Transport must be local.sock zero-copy IPC with zero token leak and zero history dump. Opus 5.5 acts as the session architect and signs off only after cross-session diffs are verified. Keep everything plain-text only and zero context bloat. Show me every change as a diff first. save it, it’ll come in handy.

STOP LETTING SONNET RUN DANGEROUS COMMANDS WITHOUT A F*CKING GUARD Claude Code just got proper hooks. Sonnet 5.5 still builds and runs tools. Haiku 5.5 runs the hooks at 340 tok/s. Opus 5.5 is the policy auditor that signs off. PreToolUse intercepts Bash and Edit before they execute. It blocks bad commands with exit code 2 and zero security leaks. PostToolUse auto-formats with ruff and prettier. Stop verifies the tests and the diff contract before the turn ends. You launch it like this: claude --model sonnet --hooks active The full tree > Sonnet 5.5 main session (effort high) edits code and executes tools > Haiku 5.5 runs PreToolUse, PostToolUse, and Stop hooks > PreToolUse guards Bash/Edit and blocks exit code 2 on bad commands > PostToolUse auto-formats with ruff + prettier (zero token overhead) > Stop verifies tests and diff contract > Opus 5.5 policy auditor signs off on every turn > 100% deterministic, zero context bloat Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high and --hooks active. Use Haiku 5.5 to run PreToolUse, PostToolUse, and Stop hooks. PreToolUse must intercept Bash and Edit, block dangerous commands with exit code 2, and allow zero security leaks. PostToolUse must auto-format with ruff and prettier. Stop must verify the test suite and the diff contract before the turn ends. Opus 5.5 acts as the policy auditor and signs off only after all hooks pass. Keep everything deterministic and zero context bloat. Show me every change as a diff first. save it, it’ll come in handy.

STOP RUNNING SEARCH AND GREP IN THE MAIN F*CKING SESSION Claude Code just got a proper subagent tip. Sonnet 5.5 is the main session. It edits and runs tests. Haiku 5.5 swarm handles search, grep, and audit. Opus 5.5 only wakes up when it actually matters. Audit runs in its own worktree so it never touches your branch. Opus stays silent on routine turns and only steps in before a plan, on the same error twice, or before done. It never writes code. Sonnet applies the advice. You launch it like this: claude --model sonnet --advisor opus The full tree > Sonnet 5.5 main session lead (effort high) > Haiku 5.5 swarm for search, grep, and audit > Audit runs in an isolated worktree > Opus 5.5 advisor on call (before plan / same error x2 / before done) > Opus reads the full session and never writes code > Sonnet applies the advice and verifies Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high and --advisor opus. Delegate search, grep, and audit to Haiku 5.5 subagents. Audit must run in a worktree. Only call Opus before a plan, when the same error hits twice, or before done. Opus reads the full session transcript and gives advice. Never writes code itself. Sonnet applies the advice, shows the diff, then verifies. Show me every change as a diff first. save it, it’ll come in handy.

STOP DUMPING THE WHOLE F*CKING REPO INTO MAIN CONTEXT Anthropic just made subagents actually usable in Claude Code. Sonnet 5.5 runs the main session and writes the code. Haiku 5.5 swarm does the heavy lifting. Opus 5.5 only architects and signs off. Haiku never dumps raw output into the main context. It distills everything through SendMessage first. Main context stays locked at 4.8k the entire time. Search, grep, and audit all run as isolated Haiku agents. Audit even mounts its own worktree so nothing touches main. JEV routes every agent and tool decision in 16ms. You launch it like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet The full tree > Sonnet 5.5 main session lead (effort MAX) > Opus 5.5 architect on call (before plan / before done) > Haiku 5.5 swarm for search, grep, and audit > Audit runs in isolated worktree > Haiku distills via SendMessage. Never dumps raw output. > Zero session bloat. Contract verified. Zero regressions. Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort MAX. Register subagents in .claude/agents and force them with CLAUDE_CODE_SUBAGENT_MODEL=haiku. Delegate search, grep, and audit to Haiku 5.5. Audit must run in an isolated worktree. Haiku distills results via SendMessage before they hit main context. Keep main context under 10k at all times. Opus only registers agents and signs off. Never writes code. Show me every change as a diff first. save it, it’ll come in handy.

STOP LETTING THE BUILDER PLAN ITS OWN F*CKING WORK Anthropic just separated planning from execution in Claude Code. Opus 5.5 only architects the AST and locks the plan. Sonnet 5.5 does the actual writing and patching. Haiku 5.5 swarm maps the repo at 340 tok/s so the main context stays clean. Opus stays silent on routine turns. It only wakes up before a plan, on test deadlock, or before done. Main context never bloats past 4.8k. JEV routes every model and tool decision in 16ms. Haiku isolates the heavy AST mapping and grep so Sonnet only sees distilled results. You launch it like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model opusplan The full tree > Opus 5.5 planner on call (before plan / on test deadlock / before done) > Sonnet 5.5 main session lead (effort MAX) > Haiku 5.5 swarm for search, grep, and docs (340 tok/s, 1M context) > JEV model router for deterministic forks > Opus never writes code. Sonnet applies the plan. > Zero session bloat. Contract verified. Zero regressions. Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort MAX. Use Opus 5.5 only as the planner with --model opusplan. Delegate search, grep, and docs to Haiku 5.5 subagents with CLAUDE_CODE_SUBAGENT_MODEL=haiku. Route model and tool decisions through the JEV router. Only call Opus before a plan, on test deadlock, or before done. Opus architects the AST and locks the schema. Never writes code itself. Sonnet synthesizes the subagent results and applies the patch. Keep main context clean. Show me every change as a diff first. save it, it’ll come in handy.

F*CK SPAMMING OPUS ON SH*T SONNET CAN HANDLE Anthropic just shipped the cleanest advisor setup in Claude Code. Sonnet 5.5 runs the main session and does the actual work. Opus 5.5 stays completely silent until it is actually needed. Haiku 5.5 subagents handle the boring stuff. Opus only wakes up in three cases: → before a plan → same error hits twice → before done It reads the full transcript and gives advice. It never writes a single line of code. Sonnet applies the advice, shows the diff, then verifies. JEV underneath resolves 3,000+ micro-forks so the lead never has to think about which file or which tool. You launch it like this: claude --model sonnet --advisor opus The full tree > Sonnet 5.5 main session lead (effort high) > Opus 5.5 advisor on call (before plan / same error x2 / before done) > Haiku 5.5 subagents for search, grep, and docs > JEV fork layer routes deterministic decisions > Opus never writes code. Sonnet applies the advice. > Zero regressions after contract verification Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high and --advisor opus. Delegate search, grep, and docs to Haiku 5.5 subagents. Route deterministic forks (which file, which tool, retry or stop) through JEV. Only call Opus when the same error hits twice, before a plan, or before done. Opus reads the full session transcript and gives advice. Never writes code itself. Sonnet applies the advice, shows the diff, then verifies. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.

F*CK WAKING OPUS FOR EVERY TINY DECISION Anthropic just shipped the cleanest advisor setup in Claude Code. Sonnet 5.5 runs the main session and does the actual work. Opus 5.5 stays silent until it is actually needed. Haiku 5.5 subagents handle the boring stuff. Opus only wakes up in three cases: → before a plan → same error hits twice → before done It reads the full transcript and gives advice. It never writes a single line of code. Sonnet applies the advice, shows the diff, then verifies. JEV underneath resolves 3,000+ micro-forks so the lead never has to think about which file or which tool. You launch it like this: claude --model sonnet --advisor opus The full tree > Sonnet 5.5 main session lead (effort high) > Opus 5.5 advisor on call (before plan / same error x2 / before done) > Haiku 5.5 subagents for search, grep, and docs > JEV fork layer routes deterministic decisions > Opus never writes code. Sonnet applies the advice. > Zero regressions after contract verification Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high and --advisor opus. Delegate search, grep, and docs to Haiku 5.5 subagents. Route deterministic forks (which file, which tool, retry or stop) through JEV. Only call Opus when the same error hits twice, before a plan, or before done. Opus reads the full session transcript and gives advice. Never writes code itself. Sonnet applies the advice, shows the diff, then verifies. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.

F*CK WRITING THE SAME PIPELINE BY HAND Anthropic just made workflows first-class in Claude Code. Opus 5.5 authors the pipeline once into `.claude/workflows`. V8 dispatcher routes it at 16ms. Haiku 5.5 sweeps the AST and fuzzes schemas. Sonnet 5.5 refactors inside isolated worktrees. The flow: → Opus writes the audit script (effort ultracode) → Haiku scans 120 files → 18 candidates, drops false positives → Sonnet patches in worktrees (+420 loc, tsc clean) → atomic mutexes + schema barrier lock the invariants → Opus synthesizes the PR and merges with zero regressions No coordinator drag. Deterministic plan. P2P mesh stays quiet. You launch it like this: claude --effort ultracode The full tree > Opus 5.5 workflow lead authors the pipeline into .claude/workflows > V8 Dynamic Workflows Dispatcher (16ms routing) > Haiku 5.5 swarm runs AST sweep + adversarial fuzz at 340 tok/s > Sonnet 5.5 workers refactor inside isolated worktrees > atomic file mutexes + schema barrier protect invariants > Opus synthesizes the cited audit report and merges to main Paste the tree + this prompt into Claude Code Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 with effort ultracode. Author the workflow once into .claude/workflows. Dispatch through the V8 16ms routing layer. Let Haiku 5.5 sweep the AST and adversarially fuzz schemas. Let Sonnet 5.5 refactor inside isolated worktrees. Use atomic file mutexes and a schema barrier so nothing collides. Opus only synthesizes the final PR after all invariants are stamped. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.

STOP MICROMANAGING YOUR F*CKING AGENTS Anthropic just dropped the cleanest agent team setup in Claude Code. Opus 5.5 leads the main session and builds the task DAG. Three Haiku 5.5 teammates self-claim work and talk to each other over a peer p2p bus. They run in parallel: → security audits JWT claims and finds a timing leak → perf-scout profiles redis locks and hits 2.8x faster → qa-engine runs the full test matrix (58/58 green) Atomic mutex DAG locks files so they never collide. JEV underneath resolves 4,800+ micro-forks (which file, which model, retry or stop) before anything reaches the lead. Opus only signs off at the end. 12/12 tasks done. Consensus approved. Zero regressions. You launch it like this: claude --model opus --teammate-mode auto The full tree > Opus 5.5 team lead builds the task DAG and coordinates > Haiku 5.5 x3 teammates - security / perf-scout / qa-engine > peer p2p bus for direct mailbox and self-claim tasks > atomic mutex DAG locks files with zero leader polling > JEV fork layer routes deterministic decisions > Opus signs off only after consensus and zero regressions Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 with effort xhigh and --teammate-mode auto. Spawn three Haiku 5.5 teammates: security, perf-scout, and qa-engine. Let them self-claim tasks from a shared DAG and communicate over a peer p2p bus. Route deterministic forks (which file, which model, retry or stop) through JEV. Use an atomic mutex DAG so teammates never collide on the same file. Opus only coordinates the plan and signs off at the end. Teammates handle the work. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.

STOP BABYSITTING F*CKING EVERY TURN Anthropic just dropped the cleanest /goal loop in Claude Code. Opus 5.5 runs in auto mode and plans + edits completely unattended. Fable 5.1 sits as the evaluator and only wakes up after each turn to check if the goal is actually met. Sonnet 5.5 dispatches three subagents in the background: → worker reads the test harness and patches → explorer maps token call sites and AST → verifier runs pytest and lint JEV sits underneath and resolves 1,700+ micro-forks in under 16ms (which file, which tool, retry or pause) before anything reaches the main session. Fable never writes code. It just reads the full transcript after every turn and says “token signature expired” or “CORS header missing Origin.” Opus applies the guidance on the next turn. 18/18 tests pass. Lint clean. Goal achieved. You launch it like this: claude --auto-mode "/goal all tests in test/auth pass and lint is clean" The full tree > Opus 5.5 auto mode plans + edits unattended > JEV 16ms fork layer resolves deterministic micro-forks > Sonnet 5.5 subagent dispatcher runs worker / explorer / verifier > Fable 5.1 evaluator checks after every turn > proves the condition in the conversation transcript > zero tool calls made, Fable never edits code Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 in auto mode with effort high. Use /goal to remove per-turn prompts. Dispatch background work to Sonnet 5.5 subagents (worker, explorer, verifier). Route deterministic forks (which file, which tool, retry or pause) through JEV at 16ms. Keep Fable 5.1 as the evaluator. It checks after each turn, reads the session transcript, and gives the reason for the next turn. Fable never edits code. It only evaluates whether acceptance criteria hold. Stop when the goal is met or an unachievable goal is caught. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.

STOP POLLUTING YOUR F*CKING MAIN BRANCH Anthropic just dropped the cleanest worktree setup in Claude Code. Sonnet 5.5 runs the main session. Everything else builds in isolated worktrees. Opus 5.5 sits on call and only wakes up when something actually breaks. Three worktrees run in parallel: → wt-auth (Sonnet medium) edits auth fixtures → wt-scout (Haiku 340 tok/s) indexes the repo AST → wt-api (Sonnet medium) runs pytest in isolation Git isolation keeps them clean. Zero index contention. When a test fails, Opus gets called, spots the mock system clock fixture, and the patch lands inside the worktree. Then it squashes everything back. 0 regressions. Main branch stays clean. You launch it like this: claude --worktree feat-auth && claude -w feat-scout --model haiku The full tree > Sonnet 5.5 high runs the main session coordinator > worktree router handles git isolation > Haiku 5.5 parallel worktree scout > wt-auth / wt-scout / wt-api run isolated > Opus 5.5 on call - only before plan, error repeats, or before merge > squash merge back with 0 regressions Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high. Build features inside isolated worktrees (wt-auth, wt-scout, wt-api). Track the repo AST on Haiku 5.5 at 340 tok/s. Keep Opus 5.5 on call. Only call it before a plan, when an error repeats, or before merge. Opus never writes code. It reads the worktree specs and gives advice. Squash the worktrees back only after a pre-flight contract check with zero regressions. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.

F*CK RUNNING OPUS ON EVERY TURN Anthropic just showed the cleanest Claude Code advisor setup. Sonnet 5.5 builds everything. Opus 5.5 sits on call and only wakes up when shit actually breaks. Sonnet runs the main session, edits, and runs tests. Three Haiku 5.5 subagents do the dirty work: → search maps the repo → grep finds call sites → docs pulls the API refs JEV sits underneath and resolves thousands of micro-forks (which file, which tool, retry or stop) before anything reaches Sonnet. Opus only gets called twice: → before a plan (reads the whole session) → when the same error hits twice It never writes code itself. It just looks at the full transcript and says “wrong fixture, not the code.” Sonnet applies the advice. Zero regressions. Contract clean. All green. You launch it like this: claude --model sonnet --advisor opus The full tree > Sonnet 5.5 runs the main session and writes code > Haiku 5.5 x3 - search / grep / docs > JEV routes deterministic forks > Opus 5.5 on call - only on same error x2 or before done > Sonnet applies the advice and verifies Paste the tree + this prompt into Claude Code Rebuild my Claude Code setup around this tree: Run the main session on Sonnet 5.5 with effort high and --advisor opus. Delegate search, grep, and docs to Haiku 5.5 subagents. Route deterministic forks (which file, which tool, retry or stop) through JEV. Only call Opus when the same error hits twice or before done. Opus reads the full session transcript and gives advice. Never writes code itself. Sonnet applies the advice, shows the diff, then verifies. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.

THIS IS A PURE F*CKING GOLDMINE Anthropic just showed one of the cleanest Claude Code tricks. Opus 5.5 writes the plan as a script, then sits idle while 3 Haiku 5.5 agents actually do the work. They run in parallel: → security audits jwt.ts and patches the timing leak → perf-scout profiles redis locks (p99 14.2ms → 3.8ms) → qa-engine runs the full auth test matrix (58/58 green) They coordinate through a peer p2p bus. No leader polling. Atomic mutexes on files. Self-claim tasks. Direct mailbox messages. JEV sits one layer down and resolves thousands of micro-forks (which file, which model, retry or stop) in code. Only the real splits ever reach Opus. Opus only appears twice: → writing the plan → signing off on the verified fixes Opus plans. Haiku scans. Sonnet ships. The full tree > Opus 5.5 runs the main session on xhigh and writes the plan > security audits on Haiku 5.5 > perf-scout profiles on Haiku 5.5 > qa-engine tests on Haiku 5.5 > peer p2p bus + atomic mutex DAG > Opus only reads what survived, then signs off > JEV handles deterministic forks in milliseconds Paste the tree + this prompt into Claude Code ↓ Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 with effort xhigh and --teammate-mode auto. Have Opus write the plan as a script: security on Haiku 5.5, perf-scout on Haiku 5.5, qa-engine on Haiku 5.5. Let the phases overlap, each finding moves forward as soon as its own stage finishes, no waiting for the batch. Never surface raw agent output to the main session, only verified results. Route deterministic forks (model choice, lane choice, retries) through JEV. Show me every change as a diff first. No edits until I say go. save it, it’ll come in handy.