·
An overlay-style Claude Code harness that pre-bakes the context-discipline patterns Anthropic recommends. Toggle it on and the next Claude Code session you launch from a yaw pane inherits a curated working style - 22 rule files, 23 slash commands, dispatch sub-agents, safety hooks - without touching the config on your disk. As of May 2026, Yaw Mode also runs against typed.cloud as a backend.
Claude Code ships with a config directory at ~/.claude/. It's where your CLAUDE.md lives, your skills, your agents, your permission allowlists, your OAuth credentials, and the JSONL transcripts for every session you've ever run. It's a deeply personal directory by the time you've used Claude Code for a few months - and anything that wants to change how Claude Code behaves has to either edit that directory in place or teach you to maintain a second config somewhere else.
Yaw Mode is a third option. It's a per-session overlay that layers an opinionated bundle on top of your ~/.claude/ without mutating it. Claude Code inside the overlay sees your CLAUDE.md plus ours, your skills plus ours, your permissions merged with a safe default set for sub-agents, and conversation history that writes straight through to your real home - so every session still shows up in --resume exactly where you'd expect. When the session ends, the overlay is gone. Your real config is untouched.
This post is the "what's in the box, how does the box work, how do I open it" tour - now updated with the slash command catalog, typed.cloud backend support, and every rule and hook we've added since launch.
Three kinds of content ride along with Yaw Mode. First: a set of rule files, merged into the overlay's CLAUDE.md in two tiers - a small always-on baseline the model sees every turn, and the rest loaded on demand when the prompt calls for them (mechanism below). Second: a curated skill set, the slash commands users invoke at runtime. Third: the hooks, custom sub-agents, and permission defaults that make dispatched work safe and reliable out of the box.
The bundle currently ships 22 rule files. Each starts with the rule, then a Why: line and a How to apply: line - the why is what lets the model (or a person reading it) decide whether an edge case falls under the rule.
They don't all ride every turn. At overlay-build time the merged CLAUDE.md is filtered against rules/manifest.json: only the rules marked applies-when.always - currently two, self-state and terminal-output - get @-imported and load on every turn. The other 20 sit on disk in the overlay's rules/ subdir and are injected on demand by the rule-trigger-load.js UserPromptSubmit hook, when your prompt matches a rule's declared triggers (up to three rules per prompt).
An overlay profile can force-load extra rules on top of that baseline: release pre-loads agent-setup, npm, deploy, scope, verification, throttle-recovery, and investigate; review pre-loads scope, verification, verification-budget, corrections, investigate, and subagent-prompts; default and exploration add none. The filter fails open - if the manifest is missing or malformed, every import is kept.
agent-setup - default to the highest-capability model tier at the backend's recommended effort. Pin runtime defaults in project-scoped settings. Yaw skills are invoked via the Skill tool, never as Agent subagent_type.corrections - when the user corrects a name (package, branch, file path), echo back the corrected form on the next reference, don't revert to the wrong form within a turn or two.deploy - reproducible builds decoupled from your workstation. Run kubectl from your workstation, not the build environment. Secrets via Secret resources, never inline env. Migrations versioned and automatic on boot.edit-tool-silent-noop - re-read a file after every Edit; the tool can report success while the file on disk is unchanged. Re-derive the match from the current state instead of replaying the same no-op.investigate - probe hypotheses yourself; don't hand the user a list. A diagnostic is tool-call shaped (ssh, curl, grep, journalctl, kubectl) - run it, surface the conclusion, not the possibilities.kubectl-debug - long kubectl read pipelines get denied by the auto-mode classifier; restructure into a single short invocation or allowlist the read-only shapes. Never allowlist destructive verbs.kubectl-verify-after-apply - always kubectl get pods after a deployment-shaped change. A successful apply only means the API accepted it; a surviving old pod masks failing new ones until the next eviction.memory - when stuck, search memory before trying a third approach. Re-read a memory you just wrote if the topic resurfaces. Resolve memory paths via the canonical env-var path, not the per-PTY tmpdir string.multi-agent-coordination - you can't message sibling sessions; coordinate through git and non-overlapping scope. When writes are authorized in a fleet, isolate in your own worktree.npm - prefer CI-on-tag-push for npm publish. Don't initiate npm login from an agent session; once logged in, write ops are fine. Never copy ~/.npmrc tokens into CI.parallel-tool-use - when you need multiple independent reads or checks, emit them in one turn. Dependent calls stay serial; don't batch writes.platform-windows - don't pass bare Unix paths to native .exe binaries from Git Bash (MSYS translates them). Test fixture keys must use path.join, not POSIX literals. The npm-on-ARM64 segfault workaround for biome.scope - finish the task first; surface the bigger fix separately. Don't read frustration as a redesign mandate. Pre-existing issues you encounter are yours to fix, not "out of scope". Surface a finding once with file:line + fix, then move on. Don't volunteer passive monitoring the user didn't ask for.self-state - verify Yaw Mode state by reading the environment, never by guessing from skill names. Don't infer runtime state from the shape of your system reminder. Verify the active API backend the same way (Anthropic-direct vs typed.cloud).shared-infra-delete - probe shared-infra dependencies before any destructive call. A repo's "unused" claim means unused by THIS repo, not by the whole account.subagent-prompts - pass sub-agents the delta, not the agent's job description. Restating the report format the skill already defines wastes tokens twice (orchestrator's prompt + sub-agent's own loaded definition).terminal-output - prefer ASCII substitutes (--, >=, x) over Unicode punctuation in terminal output. On Windows ConPTY, — becomes mojibake.throttle-recovery - server-side limits are a valid reason to drop tiers. Mechanism differs by backend - Anthropic-direct throttles trigger Yaw Terminal's "switch to Fast" toast; typed.cloud 429s mean quota exhausted, handled via dashboard top-up.verification - ask or verify load-bearing user-domain state before asserting it. Fetch the next piece of context yourself before asking the user to paste more. A justifying comment is a hypothesis, not a fact - verify external claims when the thing it explains is failing.verification-budget - verification is necessary; serial re-verification is waste. Budget two cycles per edit and declare done on the first green result.workflow-orchestration - default to a multi-agent workflow for substantive work when orchestration is on. Scope the fan-out before spawning; verify findings adversarially before reporting.yaw-shortcuts - the reference for every Yaw Terminal keyboard shortcut, translated to the platform key you actually press (Cmd on macOS, Ctrl on Windows/Linux) rather than the internal binding string.Five hooks turn previously-soft rules into mechanical behavior. All five are plain Node scripts - no bash, so they work on Windows without Git Bash - and the overlay registers them by absolute path, so they fire only inside a Yaw Mode session. Three run on PreToolUse, before the gated tool executes; two run on UserPromptSubmit, before the model sees your prompt.
gh-pr-merge-admin-gate.js (PreToolUse) - blocks gh pr merge --admin unless the invocation carries an inline # yaw-admin-authorized marker or YAW_ADMIN_AUTHORIZED=1 in env for that one command. Origin story: on 2026-04-16 an agent admin-merged a ~6,000-line deletion PR with zero CI reports, after GitHub's policy explicitly refused the normal merge. The hook makes "stop and ask" the default; the carve-out is per-invocation, not session-wide.memory-path-guard.js (PreToolUse) - blocks Write/Edit/NotebookEdit calls aimed at a per-PTY memory path belonging to a different yaw session. Claude Code's auto-memory advertises a per-PTY tmpdir path; in augment mode that path is a junction into your durable memory tree, and when the PTY tears down the junction goes with it. An agent that cached the old string keeps writing into a path that no longer resolves. The hook catches it and surfaces the canonical path to retry at.bash-mcp-nudge.js (PreToolUse) - when a Bash command has a loaded MCP server that handles the same shape, the hook redirects it. High-confidence matches are blocked with the MCP equivalent named; medium-confidence matches get an advisory and the Bash call still runs; if no relevant server is loaded it stays silent. An inline # yaw:bash marker opts a command out.rule-trigger-load.js (UserPromptSubmit) - the on-demand half of the rule loading described above. It scans your prompt for trigger strings declared in rules/manifest.json and injects up to three matching rule bodies, so the always-on prefix stays small and the full discipline still shows up when the topic does.memory-inject.js (UserPromptSubmit) - the same trick for memories. Auto-memory keeps an index in MEMORY.md but leaves the bodies on disk until an agent thinks to go looking; this hook scores each memory's description against the prompt and surfaces the top hits up front, instead of after the agent has burned tool calls re-deriving them.The bundle ships 23 skills - invoked as /yaw-* slash commands. Their bodies don't ride in the persistent system prompt; the model sees only names and one-line descriptions until you invoke one.
Full reference with shareable links: the complete slash command reference.
Sub-agents read whatever they need in their own context window and return a digest to the parent. The bundle ships:
full-pass - end-to-end sweep over a module, returning solid / fragile / worth fixing now / file for later.review-loop - independent bug/perf/UX review on recent changes. Punch list with file:line.ship-ready-audit - branch shippability check covering golden path, error UI, loading, empty states.ci-watch - polls a gh run to completion, pulls failing logs, identifies the root cause.changelog-writer - generates release notes from a git range, groups commits by area.mcp-bundle-builder - scans package.json + code for API integrations, proposes which @yawlabs/*-mcp servers to load.memory-curator - scans transcripts for memory-worthy moments. Proposes; never auto-writes.The mechanism is simpler than it sounds. When yaw spawns a Claude Code session in Yaw Mode, it:
~/.claude/ into the overlay: settings.json, .credentials.json, history.jsonl, ~/.claude.json. Hardlinks mean Claude Code reads the real file; anything it writes through the same inode reaches home directly.projects/, sessions/, plans/, file-history/. Writes go straight through to home - your --resume list is unaffected.CLAUDE_CONFIG_DIR=<overlay>. Claude Code reads its config from the overlay and never touches your real ~/.claude/.On session exit: a guarded sync of the overlay's .claude.json back to home (more on the guard below), a live-synced copy-back of refreshed OAuth credentials, and then the overlay directory is deleted. A per-session overlay, created from scratch, torn down when you're done. No accumulating state, no stale config from yesterday's session, and - critically - no risk of the overlay's teardown reaching into your real home.
Two modes. Both do the same overlay dance; they differ in what they start with.
Augment (default): your ~/.claude/ gets layered underneath the Yaw bundle. Your skills, your agents, your settings all participate. The merged CLAUDE.md is your CLAUDE.md plus Yaw's. This is the "I already have my Claude Code set up the way I like it, I just want Yaw's rules and skills on top" shape.
Fresh: only the Yaw bundle. Your ~/.claude/ is ignored for skills, agents, CLAUDE.md, settings. Conversation transcripts still route through home so you don't lose history, but the working configuration is exactly what the bundle ships - nothing more, nothing less. This is the "I want a clean slate to run the Yaw discipline against" shape, or the "I'm reproducing behavior someone else saw in Yaw Mode and need to eliminate my personal config as a variable" shape.
Both modes expose a runtime marker - $YAW_MODE is set to augment or fresh in the session env. A bundled rule tells the model to verify its own mode from that env var rather than inferring from skill names (which overlap with Claude Code built-ins and produce confident-sounding wrong answers). Small detail, but the kind of thing that matters when you're debugging why a session behaved unexpectedly.
Yaw Mode is wire-compatible with any Anthropic-API-shaped backend. As of May 2026, the most common alternative we run against is typed.cloud - an AI CLI at the same monthly price as Claude Pro/Max, with a larger default context window, cheaper extra usage, and monthly billing instead of 5-hour rolling windows. (See typed Is Live for the full pricing and migration breakdown.)
You don't need a special Yaw Mode build to use it. The typed launcher sets the right environment variables before spawning Claude Code:
export ANTHROPIC_BASE_URL=https://api.typed.cloud
export ANTHROPIC_AUTH_TOKEN=<your typed key>
export ANTHROPIC_MODEL=typed-xhighWhen Claude Code launches from a Yaw pane with those vars set, Yaw Mode picks up the backend automatically. Three things change:
agent-setup rule branches on the active backend - on Anthropic-direct it pins claude-opus-4-8 at xhigh; on typed it pins typed-xhigh (the second-from-top of typed's five tiers: typed-max / typed-xhigh / typed-high / typed-medium / typed-low). Same shape - default to the flagship at the recommended effort, reserve max for genuinely hard problems./fast works on 4.8 too, but it only speeds output and stays in the throttled pool). A 429 from typed means monthly quota exhausted, handled via dashboard one-click top-up ($5 / $10 / $20 / $50) or auto-top-up if pre-enabled. The bundle's throttle-recovery rule covers both branches.self-state rule has it check $YAW_MODE_PROVIDER and $ANTHROPIC_BASE_URL before answering. On typed it reports the typed model ID, not the Claude model the system prompt was trained to self-identify as.Both can coexist on the same machine. Open one tab against typed, another against Anthropic-direct; same conversation history, different upstreams. typed disable bounces the launcher back to your Claude subscription if you want to spread spend across both.
Because you shouldn't have to choose between your setup and ours. A replacement config would make you pick one; an overlay lets you run ours for the sessions where you want it, and your baseline the rest of the time. Opening a non-Yaw-Mode tab in yaw gets you vanilla Claude Code, reading your real ~/.claude/, same as you'd see anywhere else. Opening a Yaw-Mode tab gets you the layered version. Two tabs side by side, same conversation history, different working styles. That's the whole pitch.
It also means when Claude Code ships a new feature, you get it the day it lands - nothing in Yaw Mode is a re-implementation of Claude Code itself. The overlay is strictly additive to the official binary.
Agent quality at scale is mostly context discipline - deciding what belongs in the model's context window and what doesn't. Anthropic's engineering posts on advanced tool use and effective context engineering for AI agents cover much of the underlying material; we group the practical patterns into four levers below. Yaw Mode wasn't built to check those boxes, but all four line up cleanly with how the bundle was already shaped, which is the more useful kind of validation. We didn't add primitives Claude Code doesn't have; we shaped Yaw Mode to work with the ones it does.
1. Tool search - keep unused tool and skill schemas out of context. The Yaw bundle ships 23 skills plus 7 sub-agents. Their bodies don't ride in the persistent system prompt - they load only when invoked. The model sees their names and one-line descriptions; the multi-thousand-token instructions inside are paged in on demand. That's the difference between a 5KB persistent footprint and a 200KB one. The same treatment now covers the rules: only the always-on ones are @-imported, which puts the rule prefix at roughly 3K tokens instead of the 20K+ it would take to carry all 22 every turn (the bundle's own estimate, not a measured count).
2. Programmatic tool calling - keep intermediate tool results out of context. The Yaw sub-agents are dispatch surfaces, not paraphrasers. A full-pass over a subsystem reads dozens of files in its own context window and returns a digest - solid / fragile / worth fixing now / file for later - to the parent. The 50,000 tokens of file content stay on the sub-agent's side of the wall; the parent sees the verdict.
3. Compaction - keep stale turn history out of context. Compaction is a Claude Code primitive; what Yaw Mode contributes is making sure the cached prefix actually survives across sessions. The bundle is built to be cache-stable: rule bodies don't interpolate dates, session counters, or environment markers, and edits prefer additive changes over reordering. That keeps the largest cacheable region of the system prompt hashing identically across releases, so users hit the cache rather than re-paying full prompt cost on every new session.
4. Advisor strategy - cheap executor + capable advisor on hard sub-problems. Yaw's sub-agents are the dispatch surface for this pattern. A routine session can run on a fast tier and still escalate the genuinely hard sub-problems - an architectural review, an ambiguous debug, a ship-readiness audit - to a sub-agent pinned to a higher-tier model. The bundle's agent-setup rule has the conventions; the sub-agent boundary makes them mechanically expressible.
An overlay that shares your conversation history via junctions, hardlinks, and sync-back is a mechanism with real blast radius. "Yaw Mode broke my Claude Code history" would be an unrecoverable user experience. So the safety properties are worth spelling out, because we've done the work to make them real - including finding and fixing two data-loss edge cases in the first month.
Teardown can't touch your conversation history. Every recursive delete of an overlay directory - at session end, at startup sweep of stale overlays, at legacy-format cleanup - first unlinks the known junction points and then removes the overlay. The recursive rm sees only an empty shell; the junction targets (~/.claude/projects/, sessions/, etc.) cannot be reached, regardless of whether the Electron-bundled Node.js in a given release follows junctions or not. This is defense in depth against a behavior that shifts quietly across Node versions.
Concurrent overlays don't race each other to data loss. Running four Yaw Mode tabs in parallel used to mean only the first-to-exit's new projects landed in home's .claude.json - the rest hit a stale-snapshot guard and were silently dropped on teardown. Now the guard falls back to an additive merge: new projects get unioned in, shared projects keep home's newer values (no regression on last-session stats), counters take the max. Every overlay's additions reach home, even when four of them exit in quick succession.
Before every sync-back, we snapshot. A timestamped copy of your home .claude.json lands in ~/.yaw-claude-json-backups/. Seven are kept, pruned by age. If anything ever does slip through - and "never" is a claim we're unwilling to make about filesystem-level code on Windows - you have recovery points.
Ghost entries get cleaned up automatically. A project entry in .claude.json whose transcript directory doesn't exist on disk clutters --resume and select-to-nothing. Sync-back filters them out, so the picker only lists projects that actually have sessions to resume.
Mechanical gates on top of the rules. The PreToolUse hooks (gh-pr-merge-admin-gate.js and memory-path-guard.js) turn "the agent will remember to do the right thing" into "the agent gets blocked if it doesn't." Documented in the Hooks the bundle ships section above.
Everything is covered by tests. The junction-follow, concurrent-overlay, and ghost-filter cases all have regression tests pinned at the source level - they trip the moment anyone reintroduces the pre-fix behavior. If a future Node bump changes the filesystem primitives underneath us, those tests catch it in CI before it reaches anyone.
The bundle ships 23 skills, invoked as /yaw-* slash commands. Their bodies don't ride in the persistent system prompt; the model sees only names and one-line descriptions until you invoke one. These are the ones you'll reach for most - the full slash command reference lists all 23, with shareable per-command links.
triggers: "implement the plan", "build this", "execute the plan"
Execute an agreed plan end to end - write code, run checks, confirm it works. Use after a plan is agreed, not for open-ended exploration.
triggers: "review my changes", "any bugs in this", "spot bugs in recent changes"
Review the most recent changes for bugs, performance, and UX issues before committing or opening a PR. Returns a punch list with file:line, what's wrong, and a suggested fix.
triggers: "address all of these", "fix everything", "work the list"
Implement every actionable item from the most recent enumerated list the agent surfaced - punch list, findings, TODOs, gaps - end to end without per-item confirmations.
triggers: "what is untested", "find missing test cases", "what edge cases am I missing"
Find untested branches, edge cases, and failure paths in a module or feature. Returns a list of missing test cases with rationale - does not write tests unless asked.
triggers: "is this ready to ship", "ship-ready audit", "can I merge this"
Audit a branch or feature for shippability. Done / missing / blocked checklist covering golden path, error UI, loading states, empty states, destructive confirmations, and hygiene.
triggers: "full pass over X", "review this whole module", before a release or after a big refactor
End-to-end sweep over a module, feature, or subsystem. Reads everything carefully, reports surprises as solid / fragile / worth fixing now / file for later.
See the complete slash command reference →
Settings → Yaw Mode → toggle to Augment or Fresh. The bundle is downloaded on first use; subsequent sessions reuse the local copy. You can preview the merged CLAUDE.md from the same settings panel - useful for confirming what the model will actually see on its first turn.
Once it's on, the next Claude Code session you launch from any yaw pane inherits the overlay. Existing sessions are unaffected until you close and re-open them. Toggling back to Off reverts to vanilla Claude Code with no residue - the overlay directory was always temp-scoped to that session anyway.
To run Yaw Mode against typed.cloud instead of the Anthropic API: install the typed launcher (one curl), then enable Yaw Mode in Yaw Terminal. Each pane spawned via t or typed inherits the typed env vars; Yaw Mode picks them up automatically.
Yaw Mode is the shape you want if:
/yaw-implement, /yaw-review, /yaw-ship-ready available everywhere without installing them into every ~/.claude/skills/.It's not the shape you want if Claude Code's defaults already match the working style you want, or if you prefer to edit your own CLAUDE.md directly. Both are valid. Yaw Mode is a convenience, not a requirement.
The overlay mechanism is part of Yaw Terminal - the per-pane spawn that sets CLAUDE_CONFIG_DIR and creates the junctioned temp dir is a Yaw feature. The bundle itself (rules, skills, agents, hooks) is plain markdown and Node scripts that ship inside the Yaw Terminal install - you can copy any of it into your own ~/.claude/ and run it without the overlay, you just lose the "doesn't touch your real config" property.
Nothing. The transcript directories (projects/, sessions/, plans/, file-history/) are junctions/symlinks into your real ~/.claude/, so writes during the session go straight to home. Teardown unlinks the junction points before any recursive delete, so the overlay's rm cannot reach the target directories even if Node's filesystem behavior changes. See the safety section.
Not usefully. Everything under the yaw-mode-* tmpdir is a per-session copy that gets deleted at teardown, so an edit made through the overlay path looks like it landed and then evaporates. Edit the canonical source instead - your own files under ~/.claude/skills/ or ~/.claude/agents/, or the bundle's own copy in the Yaw Terminal install - then relaunch the session to pick it up. The memory-path-guard.js hook enforces the same rule for the one case where a stale overlay path is easiest to hit: writes aimed at another session's per-PTY memory directory.
No. The overlay is entirely local - the merged CLAUDE.md is constructed on disk in your tmp dir and read by Claude Code as part of its normal startup. Nothing about the bundle's installation or use phones home. See why your terminal shouldn't phone home for the broader Yaw Labs stance on telemetry.
No. Each pane gets a distinct tmpdir namespaced by process id + pty id. The previously-known race - four concurrent overlays exiting in quick succession losing all but one's new project entries on sync-back - was fixed by switching to an additive merge for the sync-back guard. See the safety section.
The overlay spawn is a Yaw Terminal feature. If you want the bundle's rules and skills in a non-Yaw context, copy them out of the Yaw Terminal install into ~/.claude/ and skip the overlay - you'll lose the per-session isolation but the content is the same.
Published by Yaw Labs.