AI-Assisted Engineering Workflow Playbook

<span class="cm"># 2. Check today's spend</span>
ccusage today

<span class="cm"># 3. Weekly trend with cost by model</span>
ccusage week --by-model

<span class="cm"># 4. Monthly report exported to file</span>
ccusage month --output report.txt</pre>
</div>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>For teams on Bedrock or Vertex</div>
<p>Claude Code does not send metrics to Anthropic in Bedrock and Vertex deployments. Use LiteLLM to track
spend by API key in those setups. Set up this instrumentation before expanding team usage — retroactive
cost attribution is difficult without it.</p>
</div>
<div class="callout co-lead">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M3 3v18h18" />
<path d="m19 9-5 5-4-4-3 3" />
</svg>Leadership summary — Part 1</div>
<p>Typical Claude Code usage runs <b>$150–$250 per developer per month</b>. The gap between teams with and
without workflow discipline can be substantial, but the exact range depends heavily on task mix and usage
patterns. Establish measurement tooling (ccusage, Anthropic Console) before attempting any optimization.
Per-user cost visibility is available in the Console and is the starting point for identifying outliers.
</p>
</div>
</div>
</section>
<section class="part" id="part2">
<div class="part-head">
<div class="part-badge">2</div>
<div>
<div class="part-kicker">Part 2</div>
<h2>Structuring AI Work Sessions</h2>
</div>
</div>
<p class="lead-quote">The single largest source of preventable waste in AI-assisted engineering
workflows is unstructured sessions: interactions that start without a clear scope, carry stale
context forward, apply maximum reasoning depth to routine tasks, use the wrong model for the
job, and require multiple rounds of correction to produce a usable output.</p>
<p>Each of the four concerns in this part — model selection, reasoning depth, session habits, and
context management — represents a separate optimization lever. They compound. A team that has
addressed all four is operating a materially different workflow than one that has addressed
none, even with identical tooling.</p>
<h4>Session Anatomy: Structured vs. Unstructured</h4>
<div class="cols2" style="margin:22px 0">
<div class="box" style="background:#FDEEE6;border-color:#f6d3c0">
<h5 style="color:#b24310">✗  Unstructured session</h5>
<ul style="list-style:none;padding:0">
<li>Session carries previous task context forward</li>
<li>Developer asks an underspecified question</li>
<li>Claude asks clarifying questions (turn 2)</li>
<li>First response misses intent</li>
<li>Developer corrects (turn 3)</li>
<li>Context grows with each turn</li>
<li>Mid-session model switch invalidates cache</li>
<li>Wrong implementation path pursued</li>
<li>Esc pressed after 20 minutes</li>
<li>Restart with polluted history fragment</li>
</ul>
<div
style="background:#E96719;color:#fff;font-weight:700;font-size:12.5px;padding:9px 13px;border-radius:0;margin-top:8px">
Total: 12 turns, high token count, one usable output</div>
</div>
<div class="box" style="background:#EAF7EF;border-color:#c7e8d4">
<h5 style="color:#137a3d">✓  Structured session</h5>
<ul style="list-style:none;padding:0">
<li><span class="ic">/clear</span> at session start</li>
<li><span class="ic">/context</span> verified</li>
<li>Model matched to task</li>
<li>Plan mode activated for multi-file work</li>
<li>Specific prompt submitted</li>
<li>First response usable</li>
<li>One correction turn</li>
<li><span class="ic">/compact</span> with focus hint at task boundary</li>
<li>Next task started in fresh session</li>
</ul>
<div
style="background:#1F9D55;color:#fff;font-weight:700;font-size:12.5px;padding:9px 13px;border-radius:0;margin-top:8px">
Total: 4 turns, lower token count, two usable outputs</div>
</div>
</div>
<div class="sec" id="s2-1">
<h3><span class="num">2.1</span>  Match Model Capability to Task Complexity</h3>
<p>One of the most common sources of unnecessary AI costs in engineering teams is using models
more capable than the task requires. The strongest model can cost several times more than a
mid-tier one. For routine tasks like bug fixes, test scaffolding, or renaming variables, that
extra cost adds up quickly without improving the results.</p>
<p>The framework below focuses on using each model where it delivers the most value — reserving
deep reasoning for complex tasks and using cheaper models for routine execution.</p>
<div class="callout co-do">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>DO THIS</div>
<p>Start with the cheapest model that can do the job. Step up only if quality is insufficient.</p>
</div>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Task type</th>
<th>Examples</th>
<th>Recommended model</th>
<th>Cost (input/output per MTok)</th>
</tr>
</thead>
<tbody>
<tr>
<td>Trivial / mechanical</td>
<td>Renames, getters, simple regex, boilerplate</td>
<td><b>Haiku 4.5</b></td>
<td>~$0.80 / $4</td>
</tr>
<tr>
<td>Everyday coding</td>
<td>Bug fixes, feature work, test writing, PR reviews</td>
<td><b>Sonnet 4.6</b></td>
<td>$3 / $15</td>
</tr>
<tr>
<td>Complex reasoning</td>
<td>Architectural decisions, multi-file refactors, perf work</td>
<td><b>Opus 4.7 at xhigh</b></td>
<td>$5 / $25</td>
</tr>
<tr>
<td>Large-context reading</td>
<td>Big codebase search, long document review</td>
<td><b>sonnet[1m]</b></td>
<td>$3 / $15 (1M window)</td>
</tr>
<tr>
<td>Plan + execute sessions</td>
<td>Multi-file work with planning phase</td>
<td><b>opusplan alias</b></td>
<td>~40% less than full Opus</td>
</tr>
</tbody>
</table>
</div>
<p>To switch: type <span class="ic">/model sonnet</span> or <span class="ic">/model haiku</span>. Switch at
session
boundaries only.</p>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>WATCH OUT — model switching has a hidden cost</div>
<p>Caches are per-model. Switching models mid-session forces a cold-start cache write for all prior context,
which often costs more than staying with the original model. If you need to switch, do it at a session
boundary, not in the middle of a task.</p>
</div>
<h4>How opusplan Works</h4>
<p><b>opusplan</b> is a built-in model alias that uses Opus in plan mode for architectural
decisions, then automatically switches to Sonnet when execution begins. For sessions that
would otherwise run entirely on Opus, opusplan reduces cost by roughly <b>40%</b> with no
change in planning quality.</p>
<p><b>Usage:</b> <span class="ic">/model opusplan</span> — or set as the project default in
<span class="ic">.claude/settings.json</span>: <span class="ic">{"model": "opusplan"}</span>
</p>
<p><b>Best for:</b> multi-file refactors, migrations, new feature scaffolding — any session
where planning matters but execution is mostly mechanical.</p>
<h4>Typical opusplan Session</h4>
<ol class="clean">
<li>Start Claude Code in the project root: <span class="ic">claude</span></li>
<li>Switch to opusplan: <span class="ic">/model opusplan</span></li>
<li>Enter plan mode: <b>Shift+Tab twice</b> (first press → auto-accept; second press → plan mode, shown in
status bar)</li>
<li>Describe the work: <em>"Refactor the auth flow to use OAuth2 with PKCE."</em> Claude reasons with Opus
and returns a written plan.</li>
<li>Review and approve the plan. Edit if needed. Exit plan mode (Shift+Tab) and tell Claude to proceed.</li>
<li>Execution runs on Sonnet automatically — visible in the status line. No manual switching required.</li>
</ol>
<h4>Three Ways to Set opusplan</h4>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/settings.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># Option 1: switch for the current session only</span>
/model opusplan

<span class="cm"># Option 2: set as the project default (shared with team)</span>
<span class="cm"># Edit .claude/settings.json</span>
{ "model": "opusplan" }

<span class="cm"># Option 3: set as your personal default (gitignored)</span>
<span class="cm"># Edit .claude/settings.local.json</span>
{ "model": "opusplan" }</pre>
</div>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>Note</div>
<p>opusplan uses the standard <b>200K</b> context window during the Opus planning phase. The automatic 1M
upgrade does not apply.</p>
</div>
<h4>sonnet[1m]: 1M Context Window at Sonnet Pricing</h4>
<p><b>sonnet[1m]</b> gives you a 1 million token context window at Sonnet pricing ($3/$15 per
MTok) instead of Opus pricing ($5/$25). Use it when the task is primarily about reading large
context — a large codebase, long documents — rather than complex multi-step reasoning.</p>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Option</th>
<th>Input / MTok</th>
<th>Output / MTok</th>
<th>Context</th>
<th>Best for</th>
</tr>
</thead>
<tbody>
<tr>
<td>opus</td>
<td>$5.00</td>
<td>$25.00</td>
<td>1M</td>
<td>Hard multi-step reasoning, long agentic loops</td>
</tr>
<tr>
<td>sonnet[1m]</td>
<td>$3.00</td>
<td>$15.00</td>
<td>1M</td>
<td>Reading large context, code search, document review</td>
</tr>
<tr>
<td>Difference</td>
<td>40% less</td>
<td>40% less</td>
<td>Identical</td>
<td>Quality of reasoning</td>
</tr>
</tbody>
</table>
</div>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/settings.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># Switch for the current session</span>
/model sonnet[1m]

<span class="cm"># Or set as project default (.claude/settings.json)</span>
{ "model": "sonnet[1m]" }</pre>
</div>
</div>
<div class="sec" id="s2-2">
<h3><span class="num">2.2</span>  Control Reasoning Depth and Thinking Overhead</h3>
<p>Reasoning models are valuable for complex problems, but often unnecessary for routine tasks.
Increasing reasoning depth from low to maximum can raise thinking-token usage by around
<b>10×</b>. When teams keep the highest setting enabled by default, they pay that extra cost
on every interaction, including simple ones.
</p>
<p>The solution is simple: use a lower reasoning level by default and increase it only when the
task genuinely requires deeper analysis.</p>
<div class="chart">
<div class="c-title">Opus 4.7 effort levels: xhigh on trivial work wastes tokens</div>
<div class="y-lab">Relative thinking tokens (low = 1×)</div>
<div class="bars tall">
<div class="bar">
<div class="fill" style="height:10%;background:linear-gradient(180deg,#dfe2e8,#c3c7d1)"><span
class="val">~1×</span></div><span class="lab">low</span>
</div>
<div class="bar">
<div class="fill" style="height:25%;background:linear-gradient(180deg,#f6c579,#f0a94a)"><span
class="val">~2.5×</span></div><span class="lab">medium</span>
</div>
<div class="bar">
<div class="fill" style="height:50%;background:linear-gradient(180deg,#f4b064,#ee9540)"><span
class="val">~5×</span></div><span class="lab">high</span>
</div>
<div class="bar">
<div class="fill" style="height:70%;background:linear-gradient(180deg,#f59a4d,#eb8130)"><span
class="val">~7×</span></div><span class="lab">xhigh (default)</span>
</div>
<div class="bar">
<div class="fill" style="height:100%;background:linear-gradient(180deg,#ff8c42,#E96719)"><span
class="val">~10×</span></div><span class="lab">max</span>
</div>
</div>
<div class="x-pad"></div>
<div class="c-cap">Going from low to max multiplies the number of thinking tokens by 10×. xhigh on trivial
tasks is where teams overspend most.</div>
</div>
<div class="callout co-do">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>DO THIS</div>
<p>Use medium or low effort for boilerplate, formatting, and routine bug fixes. Reserve xhigh and max for
multi-step reasoning and agentic sessions.</p>
</div>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Effort</th>
<th>Use it for</th>
</tr>
</thead>
<tbody>
<tr>
<td><b>low</b></td>
<td>Classification, extraction, formatting, short summaries, one-line edits</td>
</tr>
<tr>
<td><b>medium</b></td>
<td>Routine bug fixes, simple feature work, well-specified tests</td>
</tr>
<tr>
<td><b>high</b></td>
<td>Multi-file changes, debugging with several suspects, code review</td>
</tr>
<tr>
<td><b>xhigh (default)</b></td>
<td>Agentic coding, architectural decisions, multi-step reasoning</td>
</tr>
<tr>
<td><b>max</b></td>
<td>Hardest algorithmic problems; test before committing; can show diminishing returns</td>
</tr>
</tbody>
</table>
</div>
<h4>Three Ways to Lower Thinking Costs</h4>
<ul class="clean">
<li>Switch effort mid-session: <span class="ic">/effort low</span> or <span class="ic">/effort medium</span>
</li>
<li>Cap the thinking budget: set <span class="ic">MAX_THINKING_TOKENS=8000</span> in your environment</li>
<li>Disable thinking as your default: set <span class="ic">alwaysThinkingEnabled: false</span> in <span
class="ic">settings.local.json</span></li>
</ul>
<h4>ultrathink: High Effort for a Single Turn</h4>
<p>If your session default is medium effort, you save tokens on every routine turn. When you hit
a hard problem, add <span class="ic">ultrathink</span> anywhere in your prompt to trigger high effort for
that one turn only — without changing the session default.</p>
<ol class="clean">
<li>Confirm your session default: run <span class="ic">/effort</span>. If it is above medium, lower it:
<span class="ic">/effort medium</span>.</li>
<li>Work normally at the lower level.</li>
<li>Add <span class="ic">ultrathink</span> to any prompt that needs deep reasoning. Claude detects it and
runs that turn at high effort.</li>
<li>Check <span class="ic">/usage</span> afterward to verify the thinking tokens spent.</li>
</ol>
<h4>Example Prompts Using ultrathink</h4>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">prompt</span><button class="copy-btn" onclick="copyCode(this)"><svg viewBox="0 0 24 24"
fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># ultrathink can appear anywhere in the prompt</span>
ultrathink: why is this race condition only reproducible under load?

<span class="cm"># Or inline</span>
review the auth module and ultrathink the edge cases</pre>
</div>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>Opus 4.7 specifics</div>
<ul style='margin:6px 0 0;padding-left:18px'>
<li>Adaptive thinking is always active — you cannot set a fixed budget. Steer with effort levels and
prompt phrasing.</li>
<li>xhigh is the default for every plan tier — appropriate for hard work, wasteful for boilerplate.</li>
<li>The tokenizer uses up to <b>35% more tokens</b> for the same text compared to previous models.</li>
<li>Later turns cost more. Opus 4.7 thinks more at higher effort on longer sessions. Compact or restart at
task boundaries.</li>
</ul>
</div>
</div>
<div class="sec" id="s2-3">
<h3><span class="num">2.3</span>  Session Discipline: Where Most Waste Originates</h3>
<p>Most AI workflow waste doesn't come from a single session — it comes from carrying unnecessary
context between sessions. Developers often start new tasks in old conversations, keep irrelevant
context around, or let chat history grow unchecked. Over time, that extra context increases both
cost and overhead.</p>
<p>The practices below are ranked by impact. The first three — startup commands, focusing on one
task per session, and using <span class="ic">/compact</span> and <span class="ic">/clear</span> correctly —
deliver the
biggest reductions in unnecessary overhead.</p>
<h4>8 Habits to Build Into Every Session <span class="muted small">(the first three are the
highest-impact)</span></h4>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">1. Start Every Session with
Three Commands</div>
<div class="callout co-do">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>DO THIS</div>
<p>Run <span class="ic">/cost</span>, <span class="ic">/context</span>, and <span class="ic">/clear</span>
at the start of each session. <span class="ic">/cost</span> shows last session's spend. <span
class="ic">/context</span> shows exactly what is eating your window. <span class="ic">/clear</span> if
you are switching domains.</p>
</div>
</div>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">2. Run One Task Per Session
</div>
<p>Focused sessions use <b>40–70% fewer tokens</b> than sprawling ones. When the task is done, close the
session and start fresh for the next thing.</p>
</div>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">3. Use /compact and /clear
Correctly</div>
<p><span class="ic">/compact</span> summarizes history and replaces it with a compressed version. Checkpoint
after a discrete sub-task, not at 90% capacity.</p>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>WATCH OUT</div>
<p><span class="ic">/compact</span> sends the full conversation under a different system prompt, which
breaks the cache. You pay full uncached input rates for the entire history. Restart when work is done;
compact only to keep going on the same thread.</p>
</div>
<p>Give <span class="ic">/compact</span> a focus hint so it keeps what matters:</p>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">prompt</span><button class="copy-btn" onclick="copyCode(this)"><svg viewBox="0 0 24 24"
fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre>/compact Focus on code samples and API usage</pre>
</div>
<p>Or set permanent compaction rules in CLAUDE.md:</p>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">CLAUDE.md</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre>When compacting, always preserve: test file paths, API endpoint names, and error
messages. Drop chat banter.</pre>
</div>
</div>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">4. Rename Before You Clear
</div>
<p>Run <span class="ic">/rename my-task</span> before <span class="ic">/clear</span> so you can <span
class="ic">/resume my-task</span> later if needed.</p>
</div>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">5. Use /btw for Quick Side
Questions</div>
<p>Every question in the main session enters conversation history and is re-read on every subsequent
message. <span class="ic">/btw</span> opens a side question that uses your full session context but the
response never enters history.</p>
<ol class='clean'>
<li>Type <span class="ic">/btw</span> followed by your question. Works mid-session.</li>
<li>Read the answer in the overlay — it appears in a dismissible side panel.</li>
<li>Dismiss and continue. The main session is unaffected. The same question asked normally would add
<b>500–2,000 tokens</b> to every future turn.</li>
</ol>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">prompt</span><button class="copy-btn" onclick="copyCode(this)"><svg viewBox="0 0 24 24"
fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># Quick lookups during a long session</span>
/btw what was the name of that config file again?
/btw what does the --noEmit flag actually do?
/btw how is settings.local.json different from settings.json?</pre>
</div>
<p class='small muted'><b>Limits of /btw:</b> Full context access (Claude sees everything in the current
conversation). No tool access (cannot read new files or run commands — use a subagent for that). Single
response only (no follow-up turns within /btw).</p>
</div>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">6. Be Specific in Your Prompts
</div>
<p>Vague prompts generate clarification rounds that compound across session history.</p>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">prompt</span><button class="copy-btn" onclick="copyCode(this)"><svg viewBox="0 0 24 24"
fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># Vague: Claude asks follow-up questions</span>
<span class="s">"make this better"</span>

<span class="cm"># Specific: Claude acts immediately</span>
<span class="s">"Add input validation to login() in auth.ts:
  reject empty strings, trim whitespace,
  return a 400 with a descriptive error message."</span></pre>
</div>
</div>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">7. Use Plan Mode Before
Multi-File Work</div>
<p>Press <kbd>Shift</kbd>+<kbd>Tab</kbd> twice to enter plan mode. Claude reads the codebase and proposes an
approach before touching any files. Five minutes of planning prevents 30 minutes of wrong implementation.
</p>
</div>
<div style="border-left:4px solid #E96719;background:#F7F8FA;border-radius:0;padding:14px 18px;margin:14px 0">
<div style="font-weight:700;color:#b24310;font-size:14.5px;margin-bottom:6px">8. Cut Off Wrong Paths Early
</div>
<p>Press <kbd>Esc</kbd> to stop Claude immediately. Press <kbd>Esc</kbd> twice to open the rewind menu:
restore the conversation and code to a previous checkpoint, optionally keeping the conversation history
while reverting only the file changes. Or type <span class="ic">/rewind</span>.</p>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>WATCH OUT</div>
<p>Fast mode costs $30/$150 per MTok (6× standard Opus pricing). It persists across sessions by default.
Enable <span class="ic">fastModePerSessionOptIn: true</span> in settings.local.json to force a reset
each session.</p>
</div>
</div>
</div>
<div class="sec" id="s2-4">
<h3><span class="num">2.4</span>  Managing Context and Configuration</h3>
<p>Context management is one of the areas where team practices matter most. Without clear rules,
configuration files grow, memory accumulates, and more context gets carried into every session
than is actually needed. Over time, that creates unnecessary cost and overhead across the team.</p>
<p>The framework below separates context into four categories: what should always be loaded (team
conventions), what should be loaded only when relevant (language- or project-specific rules),
what should be loaded only when explicitly needed (workflows and procedures), and what should
never be included at all (generated files, lock files, credentials, and other low-value context).</p>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>File</th>
<th>When it loads</th>
<th>Cost profile</th>
<th>Rule of thumb</th>
</tr>
</thead>
<tbody>
<tr>
<td><span class="ic">CLAUDE.md</span></td>
<td>Every session, every turn</td>
<td>High: baseline tax on every message</td>
<td>Under 200 lines, facts only</td>
</tr>
<tr>
<td>Auto memory</td>
<td>Every session, every turn</td>
<td>Medium, grows quietly over time</td>
<td>Audit with <span class="ic">/memory</span> regularly</td>
</tr>
<tr>
<td>Skill descriptions</td>
<td>Session start only</td>
<td>Low: names only</td>
<td>Write matchable descriptions</td>
</tr>
<tr>
<td>SKILL.md body</td>
<td>On invoke only</td>
<td>Medium per use</td>
<td>Under 5,000 tokens, imperative</td>
</tr>
<tr>
<td><span class="ic">.claude/rules/</span> files</td>
<td>When matching files are open</td>
<td>Proportional to task</td>
<td>Language-specific rules</td>
</tr>
<tr>
<td><span class="ic">settings.local.json</span></td>
<td>Read once at session start*</td>
<td>Personal cost overrides only</td>
<td>Model, effort, thinking</td>
</tr>
</tbody>
</table>
</div>
<p class="small muted"><em>* model and outputStyle apply on next restart. All other keys including
effortLevel reload live.</em></p>
<h4 style="color:#b24310;font-size:13px;letter-spacing:1px;text-transform:uppercase">The trigger rule for
deciding what goes where</h4>
<div class="rules-mini">
<div class="row">
<div class="lft">Claude gets a convention wrong twice</div>
<div class="arr">→</div>
<div class="rgt">add it to CLAUDE.md</div>
</div>
<div class="row">
<div class="lft">You keep typing the same prompt to start a task</div>
<div class="arr">→</div>
<div class="rgt">save it as a skill</div>
</div>
<div class="row">
<div class="lft">A rule applies to one file type only</div>
<div class="arr">→</div>
<div class="rgt">put it in .claude/rules/</div>
</div>
<div class="row">
<div class="lft">You want personal overrides teammates skip</div>
<div class="arr">→</div>
<div class="rgt">use settings.local.json</div>
</div>
</div>
<h4>CLAUDE.md: What to Keep, What to Move</h4>
<div class="cols2">
<div class="box">
<h5>Keep in CLAUDE.md</h5>
<ul>
<li>Package manager: 'use pnpm not npm'</li>
<li>Test command: 'always run pytest before committing'</li>
<li>File naming conventions and linting rules</li>
<li>Anything that applies to 80%+ of sessions</li>
</ul>
</div>
<div class="box">
<h5>Move to a Skill or Rules File</h5>
<ul>
<li>PR review checklists</li>
<li>Migration procedures</li>
<li>Deployment steps</li>
<li>API endpoint reference material</li>
</ul>
</div>
</div>
<h4>Auto Memory: The Hidden Growing Cost</h4>
<p>Auto memory is notes Claude writes based on your corrections. It loads every session alongside
CLAUDE.md and grows quietly over time.</p>
<div class="callout co-do">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>DO THIS</div>
<p>Run <span class="ic">/memory</span> once a month. Read what is there. Remove anything outdated or
redundant with CLAUDE.md.</p>
</div>
<h4>.claude/rules/: Scoped Rules for File Types</h4>
<p>Rules files load conditionally based on which files are open. A <span
class="ic">.claude/rules/typescript.md</span>
only enters context when Claude touches TypeScript files — it costs nothing during a Python
debugging session.</p>
<div class="callout co-best">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>BEST PRACTICE</div>
<p>Reserve CLAUDE.md for conventions that apply to every session. Language-specific conventions belong in
.claude/rules/.</p>
</div>
<h4>Setting Up .claude/rules/</h4>
<ol class="clean">
<li><span class="ic">mkdir -p .claude/rules</span></li>
<li>Add one file per language: <span class="ic">typescript.md</span>, <span class="ic">python.md</span>,
<span class="ic">sql.md</span></li>
<li>Write imperative instructions, no preamble: <em>"Use strict null checks. Prefer interfaces over types.
Never use <span class="ic">any</span>."</em></li>
<li>Commit to git. Rules are project-level; every team member gets them.</li>
</ol>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>Governance note: permissions.deny</div>
<p>There is no <span class="ic">.claudeignore</span> in Claude Code. The correct mechanism is <span
class="ic">permissions.deny</span> in <span class="ic">.claude/settings.json</span>. Every file Claude
reads adds tokens to context for the rest of the session — and without deny rules, Claude can read
credentials, environment files, and sensitive configuration. Committing a baseline permissions.deny block
to project repositories ensures this protection is in place for every developer from day one.</p>
</div>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/settings.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm">// .claude/settings.json</span>
{
  <span class="p">"permissions"</span>: {
    <span class="p">"deny"</span>: [
      <span class="s">"Read(node_modules/**)"</span>, <span class="s">"Read(dist/**)"</span>,
      <span class="s">"Read(.next/**)"</span>,        <span class="s">"Read(coverage/**)"</span>,
      <span class="s">"Read(.env*)"</span>,           <span class="s">"Read(*.lock)"</span>
    ]
  }
}</pre>
</div>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>Note</div>
<p>permissions.deny restricts the Read tool. For full protection including Grep and Glob, store secrets
outside the project directory entirely.</p>
</div>
<h4>settings.local.json: Personal Cost Controls</h4>
<p><span class="ic">settings.local.json</span> sits in <span class="ic">.claude/</span> alongside <span
class="ic">settings.json</span> and
is gitignored automatically. It is where personal cost overrides go — the ones teammates should
not share.</p>
<ol class="clean">
<li>Navigate to your project root: <span class="ic">cd /path/to/your/project</span></li>
<li>Ensure Claude Code has run at least once (it creates <span class="ic">.claude/</span> automatically)
</li>
<li>Create the file: <span class="ic">touch .claude/settings.local.json</span></li>
<li>Add your personal overrides:</li>
</ol>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/settings.local.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre>{
  <span class="p">"model"</span>: <span class="s">"claude-sonnet-4-6"</span>,
  <span class="p">"effortLevel"</span>: <span class="s">"medium"</span>,
  <span class="p">"alwaysThinkingEnabled"</span>: <span class="k">false</span>,
  <span class="p">"fastModePerSessionOptIn"</span>: <span class="k">true</span>
}</pre>
</div>
<p><b>What Each Setting Does</b></p>
<ul class="clean">
<li><b>model:</b> Override the team default without affecting teammates.</li>
<li><b>effortLevel: medium</b> saves tokens on routine tasks. Pair with <span class="ic">ultrathink</span>
in prompts for turns that need deeper reasoning.</li>
<li><b>alwaysThinkingEnabled: false</b> disables extended thinking by default. Enable selectively with <span
class="ic">ultrathink</span> or <span class="ic">/effort</span>.</li>
<li><b>fastModePerSessionOptIn: true</b> forces fast mode to reset each session. Prevents silently running
at 6× Opus cost.</li>
</ul>
<div class="callout co-lead">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M3 3v18h18" />
<path d="m19 9-5 5-4-4-3 3" />
</svg>Leadership summary — Part 2</div>
<p>Model selection, reasoning depth, session discipline, and context management are the primary sources of
both cost variance and output quality variance across teams. None requires infrastructure changes — all
are configurable through settings files that can be distributed and enforced at the team level. Part 4
describes how to do that.</p>
</div>
</div>
</section>
<section class="part" id="part3">
<div class="part-head">
<div class="part-badge">3</div>
<div>
<div class="part-kicker">Part 3</div>
<h2>Building Reusable Workflow Patterns</h2>
</div>
</div>
<p class="lead-quote">Individual workflow discipline produces per-developer efficiency gains.
Reusable workflow patterns produce team-level ones, and the gains compound. A skill built once
is available to every developer on the project. A hook that catches formatting errors
automatically eliminates that correction loop for the whole team. The investment is per-team,
not per-developer.</p>
<p>This is where teams start building shared workflow knowledge into the tooling itself — not as
documentation that developers have to find and follow, but as context that loads when it is
relevant and costs nothing when it is not.</p>
<div class="sec" id="s3-1">
<h3><span class="num">3.1</span>  Progressive Context: Skills Over Static Configuration</h3>
<p>The default approach to AI context configuration — put everything the model might need into a
single file that loads at every session start — works at a small scale and breaks at a larger
scale. A <b>200-line CLAUDE.md</b> is manageable. A <b>500-line</b> one that has grown through
accumulation over months, on a 15-person team, represents thousands of tokens of overhead per
session per developer, much of it for workflows that are rarely used.</p>
<p>Skills solve this through <b>progressive disclosure</b>: a short description token (around 100
tokens) loads at startup and tells Claude what the skill does. The full skill body, which
might be 2,000–5,000 tokens, loads only when the task matches the description. Reference files
linked from the skill body load only when the skill explicitly asks for them.</p>
<div class="chart">
<div class="c-title">Skills load ~1,000 tokens at startup vs ~50,000 for CLAUDE.md</div>
<div class="hbars">
<div class="row">
<div class="name">Progressive disclosure (10 skills)</div>
<div class="track">
<div class="fill" style="width:22%;background:linear-gradient(90deg,#1F9D55,#39c076)">~1,000 tokens
</div>
</div>
</div>
<div class="row">
<div class="name">Everything in CLAUDE.md</div>
<div class="track">
<div class="fill" style="width:100%;background:linear-gradient(90deg,#E96719,#ff8c42)">~50,000 tokens
</div>
</div>
</div>
<div class="scale">
<div></div>
<div class="ticks"><span>0</span><span>20,000</span><span>Tokens load</span></div>
</div>
</div>
<div class="c-cap">10 skills with progressive disclosure cost ~1,000 tokens at startup vs ~50,000 if the
same content lived in CLAUDE.md.</div>
</div>
<div class="callout co-do">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>DO THIS</div>
<p>Move any section of CLAUDE.md that is not needed every session into a skill under <b>.claude/skills/</b>.
Each skill is a directory with one SKILL.md file.</p>
</div>
<h4>How to Create a Skill</h4>
<ol class="clean">
<li>Identify a workflow you keep repeating — PR review, test writing, deployment, migration. Anything you
have explained more than twice.</li>
<li>Create the skill directory: <span class="ic">mkdir -p .claude/skills/write-tests</span></li>
<li>Write <span class="ic">SKILL.md</span> with YAML frontmatter. Two keys: <span class="ic">name</span> and
<span class="ic">description</span>. The description is what Claude uses to decide when to load the skill,
so be specific.</li>
<li>Write imperative instructions in the body. No narrative. Tell Claude what to do, in steps.</li>
<li>(Optional) Add bundled scripts in <span class="ic">scripts/</span>. When Claude runs a script, only the
output enters context, not the script code.</li>
<li>Commit to git. Skills are project-level by default. Personal skills go in <span
class="ic">~/.claude/skills/</span> instead.</li>
</ol>
<h4>A Well-Structured SKILL.md</h4>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">SKILL.md</span><button class="copy-btn" onclick="copyCode(this)"><svg viewBox="0 0 24 24"
fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm">---</span>
<span class="p">name:</span> write-tests
<span class="p">description:</span> Use when writing or expanding tests. Covers Vitest and Playwright.
<span class="cm">---</span>
<span class="k"># Test writing conventions</span>
- Use Vitest for unit and integration tests
- Use Playwright for end-to-end tests
- Do not mock the database
- Run `pnpm test` and confirm all pass before finishing</pre>
</div>
<div class="callout co-key">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 2 15 8.5 22 9.3l-5 4.9 1.2 7L12 17.8 5.8 21.2 7 14.2l-5-4.9L9 8.5Z" />
</svg>KEY INSIGHT</div>
<p>When Claude runs a bundled script, the script's code never enters context. Only the output consumes
tokens. Validation, parsing, transforms, and lookups all belong in scripts inside the skill directory.</p>
</div>
<p>Once a skill loads, its content stays in context across turns. Auto-compaction caps each
re-attached skill at <b>5,000 tokens</b> with a shared <b>25,000-token budget</b>. Keep
individual skills under that threshold and commit them to the project repository. A skill
available to one developer costs the same to build as one available to the whole team.</p>
<h4>Where Skills Live</h4>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span class="fname">tree</span><button
class="copy-btn" onclick="copyCode(this)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor"
stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre>your-repo/
  .claude/
    skills/
      write-tests/
        SKILL.md
        scripts/
          run_vitest.sh   <span class="cm"># runs as code; only output enters context</span>

<span class="cm"># Personal skills across all your projects:</span>
~/.claude/skills/<skill-name>/</pre>
</div>
</div>
<div class="sec" id="s3-2">
<h3><span class="num">3.2</span>  Cache Discipline: The Economics of Consistency</h3>
<p>Prompt caching is the mechanism that makes extended AI coding sessions economically viable. A
cached input token costs approximately <b>10%</b> of a normal input token. In a long session
with a large system prompt, every turn either hits the cache, paying 10%, or misses it and
pays full price for the entire prior context.</p>
<div class="callout co-key">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 2 15 8.5 22 9.3l-5 4.9 1.2 7L12 17.8 5.8 21.2 7 14.2l-5-4.9L9 8.5Z" />
</svg>KEY INSIGHT</div>
<p>A cache hit costs ~10% of a normal input token. Break the cache and you pay full price for every token in
your history, every turn.</p>
</div>
<p>Cache discipline is worth treating as a team practice, not just a personal one. The most common
cache-breaking patterns (model switching mid-session, toggling MCP servers during a session,
timestamps in the system prompt) can be prevented by configuration and habit.</p>
<p>Minimum prefix length for caching: <b>1,024 tokens</b> for Sonnet; <b>4,096</b> for Opus and
Haiku 4.5. Below those thresholds, caching does nothing.</p>
<div class="chart">
<div class="c-title">Prompt caching cuts a long Opus session from $50–100 to $10–19</div>
<div class="hbars">
<div class="row">
<div class="name">With prompt caching</div>
<div class="track">
<div class="fill" style="width:19%;background:linear-gradient(90deg,#1F9D55,#39c076)">$10 – $19</div>
</div>
</div>
<div class="row">
<div class="name">Without prompt caching</div>
<div class="track">
<div class="fill" style="width:100%;background:linear-gradient(90deg,#E96719,#ff8c42)">$50 – $100
</div>
</div>
</div>
<div class="scale">
<div></div>
<div class="ticks"><span>$0</span><span>$50</span><span>Long Opus session cost ($)</span></div>
</div>
</div>
<div class="c-cap">With caching, a long Opus session costs $10–19 instead of $50–100.</div>
</div>
<h4>Five Rules to Protect Your Cache</h4>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>Rule 1: Never switch models mid-session</div>
<p>Caches are per-model. Switching Opus to Haiku cold-starts a new cache. The cold-start write often costs
more than staying with the original model.</p>
</div>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>Rule 2: Never toggle MCP servers mid-session</div>
<p>Tool definitions are part of the cached prefix. Toggle one MCP server, and everything after it is
invalidated. Pick your MCP setup at the start of the session and leave it alone.</p>
</div>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>Rule 3: Keep dynamic content out of the system prompt</div>
<p>Timestamps, current dates, git status output — anything that changes between requests must go in
messages, not in the system prompt. This is why Claude Code uses system-reminder tags inside messages.</p>
</div>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>Rule 4: Normalize whitespace in any wrappers or hooks</div>
<p>A trailing newline that sometimes gets stripped invalidates the byte-for-byte match. If anything in your
stack modifies Claude Code inputs programmatically, normalize aggressively.</p>
</div>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>Rule 5: Use /clear between unrelated tasks</div>
<p>A fresh session with cache hits from a stable system prompt is cheaper than a long polluted session that
recomputes everything from an ever-changing history.</p>
</div>
<div class="callout co-best">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>BEST PRACTICE</div>
<p>Claude Code handles caching mechanics automatically. Your job is to not break it. Do not toggle MCP
servers. Do not switch models. Do not let the system prompt change between turns.</p>
</div>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Token type</th>
<th>Multiplier vs base input</th>
<th>$/MTok (Sonnet 4.6)</th>
</tr>
</thead>
<tbody>
<tr>
<td>Base input</td>
<td>1.0×</td>
<td>$3.00</td>
</tr>
<tr>
<td>Cache write (5-min)</td>
<td>1.25×</td>
<td>$3.75</td>
</tr>
<tr>
<td>Cache write (1-hour)</td>
<td>2.0×</td>
<td>$6.00</td>
</tr>
<tr>
<td>Cache hit (read)</td>
<td>0.1×</td>
<td>$0.30</td>
</tr>
<tr>
<td>Output (incl. thinking)</td>
<td>5.0×</td>
<td>$15.00</td>
</tr>
</tbody>
</table>
</div>
</div>
<div class="sec" id="s3-3">
<h3><span class="num">3.3</span>  Tool Overhead and MCP Governance</h3>
<p>MCP servers extend Claude Code with external tool capabilities — GitHub, databases, cloud
services, and other integrations. Each connected server loads its tool definitions into
context on every message turn. This is one of the more underappreciated ongoing cost drivers
in configured Claude Code setups.</p>
<p>For individual developers, an unaudited MCP configuration is a moderate concern. For teams with
shared or standardized MCP configurations, it becomes a budget item. A configuration with four
servers averaging <b>20 tools each</b> adds <b>10,000–18,000 tokens</b> of overhead on every
turn. That number grows each time someone adds a server without checking whether it is actually
used.</p>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>MCP setup</th>
<th>Approximate tokens per turn</th>
</tr>
</thead>
<tbody>
<tr>
<td>1 server, 5 tools</td>
<td>500 – 2,500 tokens</td>
</tr>
<tr>
<td>1 server, 20 tools</td>
<td>Up to 8,000 tokens</td>
</tr>
<tr>
<td>4 servers, 20 tools each</td>
<td>10,000 – 18,000 tokens</td>
</tr>
</tbody>
</table>
</div>
<h4>Tool Search: The Default Mitigation</h4>
<p>Tool Search is enabled by default in recent versions. MCP tool definitions are deferred rather
than loaded upfront. Claude uses a search tool to discover relevant tools only when a task
needs them.</p>
<p class="small muted" style="letter-spacing:.5px;text-transform:uppercase;font-weight:700">Configuring
ENABLE_TOOL_SEARCH</p>
<ol class="clean">
<li>Choose your loading strategy: <span class="ic">auto</span> loads schemas when they fit within 10% of
context; <span class="ic">auto:5</span> at 5%; <span class="ic">true</span> always defers; <span
class="ic">false</span> always loads.</li>
<li>Set the variable in <span class="ic">.claude/settings.json</span> under the env block, or export in your
shell profile.</li>
<li>Verify with <span class="ic">/context</span> after restarting — the tool-definition section should show
"deferred."</li>
</ol>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/settings.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre>{ <span class="p">"env"</span>: { <span class="p">"ENABLE_TOOL_SEARCH"</span>: <span class="s">"auto"</span> } }</pre>
</div>
<h4>Four More MCP Cost Levers</h4>
<ul class="clean">
<li><b>Prefer CLI tools over MCP.</b> Tools like <span class="ic">gh</span>, <span class="ic">aws</span>,
<span class="ic">gcloud</span>, and <span class="ic">sentry-cli</span> add zero per-tool overhead — Claude
runs them directly without loading a schema.</li>
<li><b>Allowlist only the tools you need.</b> If your GitHub MCP server has 40 tools but you use 3, exclude
the other 37 using <span class="ic">allowed_tools</span>.</li>
<li><b>Watch MCP output size.</b> Claude Code warns when output exceeds 10,000 tokens. Don't raise <span
class="ic">MAX_MCP_OUTPUT_TOKENS</span> without a specific reason.</li>
<li><b>Disable servers you are not actively using.</b> Run <span class="ic">/mcp</span> to see all
configured servers. A connected-but-unused server still contributes tool names on every turn.</li>
</ul>
<h4>Allowlist Example: Restrict a 40-Tool GitHub Server to Three</h4>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/settings.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="p">"tool_configuration"</span>: {
  <span class="p">"enabled"</span>: <span class="k">true</span>,
  <span class="p">"allowed_tools"</span>: [<span class="s">"create_pr"</span>, <span class="s">"list_issues"</span>, <span class="s">"get_file"</span>]
}</pre>
</div>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>WATCH OUT — agent teams multiply MCP overhead</div>
<p>In agent teams, each teammate loads all connected MCP servers independently. A 3-agent team with a heavy
MCP configuration pays the overhead three times per turn. Allowlist aggressively in agentic setups.</p>
</div>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>Governance note</div>
<p>MCP configuration should be a team decision, not an individual one. Left unmanaged, servers accumulate
and tool definitions bloat every turn's context — often without anyone noticing until the bill arrives.
Reviewing MCP server configurations as part of project setup and periodic workflow audits is low-effort
with consistent returns.</p>
</div>
</div>
<div class="sec" id="s3-4">
<h3><span class="num">3.4</span>  Automation with Hooks</h3>
<p>Hooks are shell commands that run automatically at lifecycle events in a Claude Code session:
before a tool executes, after a file write, and when a session ends. Anything a script can do
reliably does not need to be done with tokens.</p>
<p>The main value of hooks is catching errors before they become rework. A formatting error caught
immediately after a file write costs a hook invocation. The same error caught three turns
later, after Claude has built further on top of it, costs multiple correction turns and
potentially a rewind.</p>
<div class="callout co-do">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>DO THIS</div>
<p>Add a PostToolUse hook to run your formatter and type-checker after every file write. Errors caught in
seconds do not become 10-turn rework loops.</p>
</div>
<h4>How to Add a PostToolUse Hook</h4>
<ol class="clean">
<li>Open or create <span class="ic">.claude/settings.json</span> in your project root.</li>
<li>Add a hooks block. The <span class="ic">matcher</span> field is a regex over tool names.</li>
<li>Save the file. Claude Code reloads hook config live; no restart needed.</li>
<li>Verify with <kbd>Ctrl</kbd>+<kbd>O</kbd> — toggle verbose mode to see hook stdout/stderr in the
terminal.</li>
<li>Trigger a test edit. The hook should run prettier and tsc after the edit completes.</li>
</ol>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/settings.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm">// .claude/settings.json</span>
{
  <span class="p">"hooks"</span>: {
    <span class="p">"PostToolUse"</span>: [{
      <span class="p">"matcher"</span>: <span class="s">"Edit|Write|MultiEdit"</span>,
      <span class="p">"hooks"</span>: [
        { <span class="p">"type"</span>: <span class="s">"command"</span>, <span class="p">"command"</span>: <span class="s">"prettier --write $CLAUDE_FILE_PATH"</span> },
        { <span class="p">"type"</span>: <span class="s">"command"</span>, <span class="p">"command"</span>: <span class="s">"tsc --noEmit"</span> }
      ]
    }]
  }
}</pre>
</div>
<h4>Hook Preprocessing: Filter Verbose Output</h4>
<p>A PreToolUse hook can intercept a command before Claude sees the output. For test runs, filter
to failures only — 10,000 lines of test output becomes 100 lines that fit in context.</p>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">hook.sh</span><button class="copy-btn" onclick="copyCode(this)"><svg viewBox="0 0 24 24"
fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># PreToolUse hook: filter test output to failures only</span>
<span class="k">if</span> [[ <span class="s">"$cmd"</span> =~ ^(npm test|pytest|go test) ]]; <span class="k">then</span>
  filtered=<span class="s">"$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR)' | head -100"</span>
<span class="k">fi</span></pre>
</div>
<h4>Other High-Value Hooks</h4>
<ul class="clean">
<li>PreToolUse hook blocking writes to protected paths</li>
<li>Stop hook running a final lint pass before handing back to you</li>
<li>PostToolUse on Bash to log commands for debugging long agentic runs</li>
</ul>
<div class="callout co-lead">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M3 3v18h18" />
<path d="m19 9-5 5-4-4-3 3" />
</svg>Leadership summary — Part 3</div>
<p>Skills reduce per-session startup overhead and make workflow knowledge shareable. Cache discipline
ensures that investment pays off on every turn. MCP governance prevents new servers from silently undoing
it. Hooks remove correction loops before they start. Together, they are what separate a team of developers
each using AI independently from a team running AI-assisted workflows with any consistency.</p>
</div>
</div>
</section>
<div class="cta-mini">
<div class="cta-strip">
<div class="k">
<span class="eyebrow">From individual habits to team standards</span>
<h3>Ready to make these workflows the default across your team?</h3>
<p>Akvelon's engineers deploy this configuration — instrumentation, shared skills, governance —
as a standard part of delivery. Bring us in to set the baseline with you.</p>
<div class="row">
<a class="btn btn-white" href="https://akvelon.com/contact-us/">Talk to our engineers</a>
<a class="btn btn-ghost-w" rel="nofollow" href="#reference">Jump to the checklists</a>
</div>
</div>
</div>
</div>
<section class="part" id="part4">
<div class="part-head">
<div class="part-badge">4</div>
<div>
<div class="part-kicker">Part 4</div>
<h2>Operating at Team Scale</h2>
</div>
</div>
<p class="lead-quote">Parts 2 and 3 describe what individual and project-level workflow discipline
looks like. Part 4 covers what happens when you need to operate this across a team.</p>
<p>Three concerns dominate at the team scale: <b>cost predictability</b> — can you forecast AI
infrastructure spend before the bill arrives? <b>Output consistency</b> — are developers getting
comparable results, or does quality vary by who is asking? And <b>operational visibility</b> —
can engineering leadership see what is happening, identify outliers, and act on it?</p>
<p>None of this requires new infrastructure. It requires consistent configuration and the
willingness to treat AI workflow decisions as team standards rather than personal preferences.</p>
<div class="sec" id="s4-1">
<h3><span class="num">4.1</span>  Agent Workflows and Subagents</h3>
<p>Subagents are self-contained Claude Code processes with their own context windows. The main
session receives only the subagent's output, keeping its own context lean regardless of how
much work the subagent performs. This makes subagents the right pattern for heavy exploration,
parallel investigation, and codebase audits where you want the findings without the context
pollution.</p>
<p>The tradeoff: subagents save your main context window, not your total token spend. Each
subagent has its own bootstrap overhead and runs its own full session. For small lookups or
quick questions, spawning a subagent costs more than asking directly. Use the pattern when the
task is genuinely heavy, when the output is a file or summary rather than an inline response,
and when context isolation matters.</p>
<h4>When to Use a Subagent</h4>
<ul class="clean">
<li>Heavy exploration that would pollute your main thread (reading 30 files to map an unfamiliar feature)
</li>
<li>Parallel investigations where multiple subagents do read-only research simultaneously</li>
<li>Codebase audits where the output is a summary, not a code change</li>
<li>Specialized roles with restricted tools (a "reviewer" agent that only reads, never writes)</li>
</ul>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>WATCH OUT</div>
<p>Subagent bootstrap overhead can run 10–20K tokens before any user task begins. Don't spawn subagents for
trivial questions.</p>
</div>
<div class="callout co-do">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M20 6 9 17l-5-5" />
</svg>DO THIS</div>
<p>Have the subagent write findings to a file, not return them inline. The main session reads only the parts
it needs. This is the pattern that actually reduces total spend.</p>
</div>
<h4>How to Create and Invoke a Subagent</h4>
<ol class="clean">
<li>Create the agents directory: <span class="ic">mkdir -p .claude/agents</span></li>
<li>Create one Markdown file per agent role: <span class="ic">explorer.md</span>, <span
class="ic">reviewer.md</span>, <span class="ic">security-audit.md</span></li>
<li>Add YAML frontmatter with required fields: <span class="ic">name</span>, <span
class="ic">description</span>, <span class="ic">tools</span>, <span class="ic">model</span>. Tools
restricts what the agent can do.</li>
<li>Write the agent's instructions: imperative steps. Tell it where to write findings and what to summarize
back.</li>
<li>Invoke from your main session: <em>"Use the explorer agent to map the auth module."</em> Claude
delegates automatically and returns only the summary.</li>
</ol>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">.claude/agents/explorer.md</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># Example: .claude/agents/explorer.md</span>
<span class="cm">---</span>
<span class="p">name:</span> explorer
<span class="p">description:</span> Reads many files to map a feature area. Returns short summary,
  writes detailed findings to a file.
<span class="p">tools:</span> [Read, Grep, Glob, Write]
<span class="p">model:</span> claude-haiku-4-5
<span class="cm">---</span>
1. Read all files relevant to the requested area.
2. Write detailed findings to docs/exploration-<topic>.md.
3. Return a 5-sentence summary to the parent session
   plus the path to the detailed file.

<span class="cm"># Invoke from main session:</span>
<span class="s">"Use the explorer agent to map the auth module"</span></pre>
</div>
<div class="callout co-watch">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 9v4" />
<path d="M12 17h.01" />
<path d="M10.3 3.9 1.8 18a2 2 0 0 0 1.7 3h17a2 2 0 0 0 1.7-3L13.7 3.9a2 2 0 0 0-3.4 0Z" />
</svg>Agent teams: use with intent</div>
<p>Agent teams use approximately <b>7×</b> more tokens than a standard single-agent session when teammates
run in plan mode. They are disabled by default. The pattern fits complex, genuinely parallel workstreams,
not routine coding tasks. Enable them intentionally: <span
class="ic">CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1</span></p>
<p>Every active teammate consumes tokens even when idle. Clean up agent teams when work is done.</p>
</div>
<h4>If You Use Agent Teams</h4>
<ol class="clean">
<li>Use Sonnet for teammates. Teammate tasks rarely require Opus-level reasoning.</li>
<li>Keep teams small. Token usage scales roughly proportionally to team size.</li>
<li>Keep spawn prompts focused. Teammates automatically load CLAUDE.md, MCP servers, and skills — everything
extra adds to starting context.</li>
<li>MCP overhead multiplies. Each teammate loads all connected MCP servers independently. Allowlist
aggressively.</li>
</ol>
</div>
<div class="sec" id="s4-2">
<h3><span class="num">4.2</span>  Team Controls and Governance</h3>
<p>Individual workflow discipline scales only as far as individual habits. Consistent AI-assisted
development practices across a team require governance at the configuration level, not just
through documentation and training.</p>
<p>Claude Code provides several levers for team-level control, organized below by the concern they
address.</p>
<h4>Cost Predictability Controls</h4>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Control</th>
<th>What it does</th>
<th>Where to configure</th>
</tr>
</thead>
<tbody>
<tr>
<td><span class="ic">availableModels</span></td>
<td>Restricts which models developers can select. Prevents individual drift toward high-cost models
for routine work.</td>
<td><span class="ic">managed-settings.json</span> on each developer machine</td>
</tr>
<tr>
<td>Workspace spend limits</td>
<td>Monthly cap that blocks usage when exceeded. Blunt but effective as a ceiling control.</td>
<td>Anthropic Console → Settings</td>
</tr>
<tr>
<td><span class="ic">fastModePerSessionOptIn: true</span></td>
<td>Requires opt-in to fast mode each session. Prevents accidental 6× billing from a mode that
persists by default.</td>
<td><span class="ic">managed-settings.json</span></td>
</tr>
<tr>
<td><span class="ic">CLAUDE_CODE_DISABLE_FAST_MODE=1</span></td>
<td>Removes fast mode entirely for all users. Use when the cost multiplier is not acceptable for any
use case.</td>
<td><span class="ic">managed-settings.json</span> env block</td>
</tr>
<tr>
<td>Per-user cost breakdown</td>
<td>Shows individual spend in the Console. Starting point for identifying outliers and coaching
conversations.</td>
<td>platform.claude.com/usage</td>
</tr>
</tbody>
</table>
</div>
<h4>Output Consistency Controls</h4>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Control</th>
<th>What it does</th>
<th>Where to configure</th>
</tr>
</thead>
<tbody>
<tr>
<td>Team default model in <span class="ic">settings.json</span></td>
<td>Sets a shared model baseline for the project. Developers can override personally in <span
class="ic">settings.local.json</span>.</td>
<td><span class="ic">.claude/settings.json</span> committed to repo</td>
</tr>
<tr>
<td>Shared skills library</td>
<td>Ensures all developers have access to the same workflow context for common tasks. Reduces variance
in output quality for defined procedures.</td>
<td><span class="ic">.claude/skills/</span> committed to repo</td>
</tr>
<tr>
<td><span class="ic">.claude/rules/</span> files</td>
<td>Language-specific conventions committed to the project. Every developer picks them up
automatically.</td>
<td><span class="ic">.claude/rules/</span> committed to repo</td>
</tr>
<tr>
<td>Default effort level</td>
<td>Sets a consistent reasoning depth baseline. Prevents xhigh on routine tasks across the team.</td>
<td><span class="ic">managed-settings.json</span> or <span class="ic">settings.json</span></td>
</tr>
</tbody>
</table>
</div>
<h4>Operational Visibility Practices</h4>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Practice</th>
<th>Cadence</th>
<th>What to look for</th>
</tr>
</thead>
<tbody>
<tr>
<td>Per-user cost review in Console</td>
<td>Weekly</td>
<td>Sustained outliers above $30/active day; sudden spikes</td>
</tr>
<tr>
<td>ccusage weekly trend report</td>
<td>Weekly</td>
<td>Week-over-week cost trends; model mix changes</td>
</tr>
<tr>
<td>Shared skills audit</td>
<td>Monthly</td>
<td>Skills that haven't been invoked; descriptions that don't match usage</td>
</tr>
<tr>
<td>CLAUDE.md and auto memory review</td>
<td>Monthly</td>
<td>Accumulated content that no longer reflects current practice</td>
</tr>
<tr>
<td>MCP server configuration review</td>
<td>Quarterly or on new project setup</td>
<td>Unused servers; tools that could be replaced with CLI equivalents</td>
</tr>
</tbody>
</table>
</div>
<h4>Lock Model Selection with availableModels</h4>
<p>Admins on Team and Enterprise plans can restrict which models users can select. The
<span class="ic">model</span> field sets the starting default; <span class="ic">availableModels</span> is
the allowlist.
</p>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">managed-settings.json</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm">// managed-settings.json</span>
{
  <span class="p">"model"</span>: <span class="s">"sonnet"</span>,
  <span class="p">"availableModels"</span>: [<span class="s">"sonnet"</span>, <span class="s">"haiku"</span>]
}</pre>
</div>
<p>When <span class="ic">availableModels</span> is set, users cannot switch to any model not on the list via
<span class="ic">/model</span>, the <span class="ic">--model</span> flag, or the <span
class="ic">ANTHROPIC_MODEL</span> environment
variable.
</p>
<h4>How to Deploy managed-settings.json</h4>
<ol class="clean">
<li>Choose the install path for your OS.</li>
<li>Create the file at that path.</li>
<li>Distribute via MDM (Jamf, Intune, Kandji) for production rollout, or commit a deployment script to your
infra repo.</li>
<li>Verify on a user machine: have a teammate run <span class="ic">/model</span> after picking up the
deployment. Restricted models should not appear in the picker.</li>
</ol>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">install-paths</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre><span class="cm"># macOS</span>
/Library/Application Support/ClaudeCode/managed-settings.json

<span class="cm"># Linux / WSL</span>
/etc/claude-code/managed-settings.json

<span class="cm"># Windows</span>
C:\Program Files\ClaudeCode\managed-settings.json</pre>
</div>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>Note</div>
<p>The Default option in the <span class="ic">/model</span> picker is not restricted by <span
class="ic">availableModels</span>. To control what Default resolves to, also set <span
class="ic">ANTHROPIC_DEFAULT_SONNET_MODEL</span> in the env block.</p>
</div>
<h4>Full Model Reference</h4>
<div class="tbl-wrap">
<table>
<thead>
<tr>
<th>Model</th>
<th>Input / Output per MTok</th>
<th>Context</th>
<th>Best for</th>
</tr>
</thead>
<tbody>
<tr>
<td><b>Opus 4.7</b></td>
<td>$5 / $25</td>
<td>1M tokens</td>
<td>Long agentic tasks, outputs over 64K, vision</td>
</tr>
<tr>
<td><b>Opus 4.6</b></td>
<td>$5 / $25</td>
<td>1M tokens</td>
<td>Same capability as 4.7, no API breaking changes</td>
</tr>
<tr>
<td><b>Sonnet 4.6</b></td>
<td>$3 / $15</td>
<td>1M tokens</td>
<td>Most coding work; best price/quality ratio</td>
</tr>
<tr>
<td><b>Haiku 4.5</b></td>
<td>~$0.80 / $4</td>
<td>200K tokens</td>
<td>High-volume, low-complexity, background tasks</td>
</tr>
</tbody>
</table>
</div>
<div class="callout co-note">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<circle cx="12" cy="12" r="9" />
<path d="M12 8h.01" />
<path d="M11 12h1v4h1" />
</svg>Note</div>
<p>Sonnet 4.6 achieves <b>95–99%</b> of Opus-level effectiveness on coding tasks at <b>40% lower cost</b>.
Use Opus 4.7 when you need outputs longer than 64K tokens or the January 2026 knowledge cutoff. Sonnet
4.6's cutoff is August 2025.</p>
</div>
</div>
<div class="sec" id="s4-3">
<h3><span class="num">4.3</span>  Reference Configuration</h3>
<p>Team configuration standards distribute through two mechanisms: the project repository
(<span class="ic">.claude/settings.json</span>, skills, rules files) handles workflow context — shared
skills, project conventions, hook configurations. <span class="ic">Managed-settings.json</span> deployed via
MDM handles cost controls and model governance.</p>
<h4>Recommended Deployment Sequence for New Teams</h4>
<ol class="clean">
<li><b>Instrument first.</b> Set up ccusage and Anthropic Console visibility before configuring anything
else. You need a baseline to evaluate changes against.</li>
<li><b>Set defaults in settings.json.</b> Commit a project-level default model and effort level. This
establishes the team baseline without restricting individual flexibility.</li>
<li><b>Add permissions.deny.</b> Commit baseline deny rules for credentials, generated output, and lock
files. This has immediate cost and security value.</li>
<li><b>Build the first two or three skills.</b> Start with the workflows developers repeat most — PR review,
test writing, migration procedures. Commit them to the repository.</li>
<li><b>Configure hooks.</b> Add PostToolUse hooks for formatting and type-checking. These reduce correction
loops immediately.</li>
<li><b>Add governance controls via MDM.</b> Once the team has established workflow habits, add <span
class="ic">availableModels</span> and spend limits as a ceiling, not a starting point.</li>
</ol>
<p>This layout applies every technique in the guide. Copy and adapt to your project.</p>
<div class="code">
<div class="code-bar"><span class="dots"><i></i><i></i><i></i></span><span
class="fname">project-layout</span><button class="copy-btn" onclick="copyCode(this)"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<rect x="9" y="9" width="12" height="12" rx="2" />
<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
</svg><span>Copy</span></button></div>
<pre>your-repo/
  CLAUDE.md                <span class="cm"># under 200 lines, invariants only</span>
  .claude/
    settings.json          <span class="cm"># hooks + permissions.deny + availableModels</span>
    settings.local.json    <span class="cm"># personal overrides: model, effort, thinking</span>
    rules/
      typescript.md        <span class="cm"># loads only when editing .ts files</span>
      python.md            <span class="cm"># loads only when editing .py files</span>
    skills/
      auth-flows/
        SKILL.md
        scripts/
          validate_jwt.py  <span class="cm"># only output enters context</span>
      db-migrations/
        SKILL.md
        REFERENCE.md       <span class="cm"># loaded only when SKILL.md says so</span>
        scripts/
          generate_migration.py
    agents/
      explorer.md          <span class="cm"># subagent for heavy research (Haiku)</span>
      reviewer.md          <span class="cm"># subagent for code review (Sonnet)</span>
  src/
    ...</pre>
</div>
<h4>Why Each Piece Is There</h4>
<ul class="clean">
<li><b>CLAUDE.md under 200 lines</b> — it loads every session. Only what applies to 80%+ of tasks.</li>
<li><b>permissions.deny in settings.json</b> — blocks credentials, generated output, and lock files.</li>
<li><b>.claude/rules/</b> — language-specific conventions at zero cost in unrelated sessions.</li>
<li><b>settings.local.json</b> — lets each developer run leaner without affecting teammates.</li>
<li><b>Hooks in settings.json</b> — run formatters and type-checkers without LLM tokens.</li>
<li><b>Subagents use Haiku or Sonnet</b>, not Opus, with file-based handoff.</li>
<li><b>Bundled scripts inside skills</b> — handle deterministic work; only output enters context.</li>
</ul>
<div class="callout co-lead">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M3 3v18h18" />
<path d="m19 9-5 5-4-4-3 3" />
</svg>Leadership summary — Part 4</div>
<p>Team-scale governance requires consistent configuration distributed through standard developer tooling —
not new infrastructure. The primary mechanisms: managed-settings.json for cost controls and model
governance; the project repository for shared workflow context (skills, rules, hooks); the Anthropic
Console for operational visibility. Start with instrumentation, then add controls progressively. Trying to
govern everything at once tends to produce friction without the workflow foundation to support it.</p>
</div>
</div>
</section>
<section class="part" id="reference">
<div class="part-head">
<div class="part-badge">R</div>
<div>
<div class="part-kicker">Reference</div>
<h2>Checklists</h2>
</div>
</div>
<p>Two checklists follow. The developer checklist covers daily and per-session habits. The team lead
checklist covers setup, governance, and review practices. Both can be used independently.
Tick items off as you go — your progress is saved in this browser.</p>
<div class="checkzone">
<div class="tabs">
<button class="tab active" data-tab="dev">
<div class="t-t">Developer Checklist</div>
<div class="t-s">Daily and per-session practices</div>
</button>
<button class="tab" data-tab="lead">
<div class="t-t">Team Lead / Engineering Leader</div>
<div class="t-s">Setup, governance & review cadence</div>
</button>
</div>
<div class="panel active" data-panel="dev">
<div class="chk-actions">
<span class="progress-note" data-progress="dev">0 of 0 complete</span>
<button class="reset-btn" data-reset="dev">Reset developer checklist</button>
</div>
<div class="grp"><span class="hd">Before Each Session</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Run <span
class="ic">/cost</span> to see last session's spend and gauge where you are relative to baseline
($13/day average).</span></label><label class="chk"><input type="checkbox"><span class="txt">Run
<span class="ic">/context</span> to see what is loaded in your context window. Identify anything
that should not be there.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Run <span class="ic">/clear</span> if you are starting a new task. Don't carry
yesterday's context into today's work.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Choose the right model for the task. Haiku for boilerplate; Sonnet 4.6 for everyday
coding; Opus 4.7 only when reasoning quality is the bottleneck.</span></label><label
class="chk"><input type="checkbox"><span class="txt">Set your effort level. <span
class="ic">effortLevel: medium</span> in <span class="ic">settings.local.json</span> for most
sessions. Use <span class="ic">ultrathink</span> in prompts for turns that need deep
reasoning.</span></label></div>
</div>
<div class="grp"><span class="hd">During Each Session</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Run one task per session.
When the task is done, close the session. Start fresh for the next thing.</span></label><label
class="chk"><input type="checkbox"><span class="txt">Use <span class="ic">/btw</span> for quick side
questions that should not enter conversation history.</span></label><label class="chk"><input
type="checkbox"><span class="txt">Write specific prompts. Include scope, file location, and expected
output. Vague prompts generate clarification turns that compound across
history.</span></label><label class="chk"><input type="checkbox"><span class="txt">Press
<kbd>Shift</kbd>+<kbd>Tab</kbd> twice before multi-file work. Plan mode. Review the plan before
proceeding.</span></label><label class="chk"><input type="checkbox"><span class="txt">Press
<kbd>Esc</kbd> immediately when Claude takes a wrong path. Use <span class="ic">/rewind</span> to
restore to a checkpoint rather than correcting forward in a polluted context.</span></label><label
class="chk"><input type="checkbox"><span class="txt">Do not switch models mid-session. If you need to
switch, do it at a session boundary.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Do not toggle MCP servers mid-session. Both actions invalidate the prompt
cache.</span></label></div>
</div>
<div class="grp"><span class="hd">At Session Boundaries</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Run <span
class="ic">/rename</span> before <span class="ic">/clear</span> if there is any chance you will
need to resume the thread.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Use <span class="ic">/compact</span> with a focus hint when you need to continue a long
session: <span class="ic">/compact Focus on API endpoints and error
messages</span>.</span></label><label class="chk"><input type="checkbox"><span class="txt">Run
<span class="ic">/usage</span> to see total session cost, API duration, and lines changed before
closing.</span></label></div>
</div>
<div class="grp"><span class="hd">Weekly</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Run <span
class="ic">ccusage week --by-model</span> to review weekly spend trend and model
mix.</span></label><label class="chk"><input type="checkbox"><span class="txt">Check per-day cost
against the $13 average and $30 ceiling. Investigate sustained outliers.</span></label></div>
</div>
<div class="grp"><span class="hd">Monthly</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Run <span
class="ic">/memory</span> and audit auto memory. Remove anything outdated or redundant with
CLAUDE.md.</span></label><label class="chk"><input type="checkbox"><span class="txt">Review
CLAUDE.md length. If it is over 200 lines, move low-frequency content to skills or <span
class="ic">.claude/rules/</span>.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Check which skills you have used. Uninvoked skills may have descriptions that do not
match how you actually phrase tasks.</span></label></div>
</div>
<div class="grp"><span class="hd">Structural Setup (one-time or on new projects)</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Create <span
class="ic">settings.local.json</span> with your personal overrides: model, effort level,
alwaysThinkingEnabled, fastModePerSessionOptIn.</span></label><label class="chk"><input
type="checkbox"><span class="txt">Install ccusage: <span class="ic">npm install -g
ccusage</span></span></label><label class="chk"><input type="checkbox"><span class="txt">Verify
<span class="ic">permissions.deny</span> is configured in <span
class="ic">.claude/settings.json</span>. Block: node_modules, dist, .next, coverage, .env files,
*.lock files.</span></label><label class="chk"><input type="checkbox"><span class="txt">Confirm
<span class="ic">.claude/rules/</span> exists with language-specific convention files for the
languages you work with most.</span></label></div>
</div>
</div>
<div class="panel" data-panel="lead">
<div class="chk-actions">
<span class="progress-note" data-progress="lead">0 of 0 complete</span>
<button class="reset-btn" data-reset="lead">Reset team lead checklist</button>
</div>
<div class="grp"><span class="hd">Initial Setup (before team usage scales)</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Set up Anthropic Console
access for per-user visibility and distribute ccusage. Do this before anything
else.</span></label><label class="chk"><input type="checkbox"><span class="txt">Record average
per-developer daily spend before making configuration changes. You need a before to evaluate the
after.</span></label><label class="chk"><input type="checkbox"><span class="txt">Commit baseline
<span class="ic">.claude/settings.json</span> to the project repository — model, effort default,
permissions.deny.</span></label><label class="chk"><input type="checkbox"><span class="txt">Commit a
baseline permissions.deny block. Both a cost control and a security measure.</span></label><label
class="chk"><input type="checkbox"><span class="txt">Deploy <span
class="ic">managed-settings.json</span> via MDM — <span class="ic">fastModePerSessionOptIn:
true</span> at minimum.</span></label></div>
</div>
<div class="grp"><span class="hd">Shared Workflow Infrastructure</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Identify the three to five
workflows developers repeat manually: PR review, test writing, migration procedures, deployment
steps.</span></label><label class="chk"><input type="checkbox"><span class="txt">Build and commit
skills for those workflows to <span class="ic">.claude/skills/</span>. Include bundled scripts for
deterministic work.</span></label><label class="chk"><input type="checkbox"><span class="txt">Commit
<span class="ic">.claude/rules/</span> files for each primary language in the
project.</span></label><label class="chk"><input type="checkbox"><span class="txt">Configure
PostToolUse hooks for formatting and type-checking in <span class="ic">.claude/settings.json</span>.
Commit to the repository.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Define standard agent configurations if agentic workflows are in use (<span
class="ic">explorer.md</span>, <span class="ic">reviewer.md</span> in <span
class="ic">.claude/agents/</span>).</span></label></div>
</div>
<div class="grp"><span class="hd">Cost and Model Governance</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Set <span
class="ic">availableModels</span> in <span class="ic">managed-settings.json</span> to restrict
model selection to Sonnet and Haiku for routine work. Add Opus only if the team regularly needs
it.</span></label><label class="chk"><input type="checkbox"><span class="txt">Set a workspace spend
limit in the Anthropic Console.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Set <span class="ic">CLAUDE_CODE_DISABLE_FAST_MODE=1</span> in <span
class="ic">managed-settings.json</span> unless fast mode is explicitly required (it bills at 6×
standard Opus pricing).</span></label><label class="chk"><input type="checkbox"><span
class="txt">Document the team's model selection policy. Which tasks warrant Opus? When should effort
level be escalated? Write it down.</span></label></div>
</div>
<div class="grp"><span class="hd">Ongoing Review Cadence</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Weekly: Review per-user
cost in Anthropic Console. Flag sustained outliers above $30/active day for a workflow conversation,
not a reprimand.</span></label><label class="chk"><input type="checkbox"><span class="txt">Weekly:
Run <span class="ic">ccusage week --by-model</span>. A shift toward Opus without a corresponding
complexity increase warrants a look.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Monthly: Audit shared skills. Remove ones that haven't been invoked. Fix descriptions
for skills being triggered inconsistently.</span></label><label class="chk"><input
type="checkbox"><span class="txt">Monthly: Review CLAUDE.md and auto memory across projects. Remove
accumulated content that no longer reflects current practice.</span></label><label
class="chk"><input type="checkbox"><span class="txt">Quarterly: Review MCP server configurations.
Identify unused servers. Replace with CLI equivalents where possible.</span></label><label
class="chk"><input type="checkbox"><span class="txt">Quarterly: Assess whether AI workflow investment
is producing visible engineering outcomes. Focus on qualitative signals: developer perception,
rework rates, time-to-first-usable-output trends.</span></label></div>
</div>
<div class="grp"><span class="hd">Team Onboarding</span>
<div class="checks"><label class="chk"><input type="checkbox"><span class="txt">Include the developer
checklist in the team's engineering onboarding documentation.</span></label><label
class="chk"><input type="checkbox"><span class="txt">Walk new developers through <span
class="ic">settings.local.json</span> setup on their first day. Personal defaults are easy to set
and compound from day one.</span></label><label class="chk"><input type="checkbox"><span
class="txt">Review the shared skills library with new team members. Ensure they know what exists and
how to invoke it.</span></label><label class="chk"><input type="checkbox"><span class="txt">Set
expectations explicitly: model selection, effort levels, and session habits are team practices, not
personal preferences.</span></label></div>
</div>
</div>
</div>
<div class="callout co-key">
<div class="tag"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"
stroke-linecap="round" stroke-linejoin="round">
<path d="M12 2 15 8.5 22 9.3l-5 4.9 1.2 7L12 17.8 5.8 21.2 7 14.2l-5-4.9L9 8.5Z" />
</svg>A Note on Currency</div>
<p>The specific numbers and configuration examples in this playbook will change as Claude Code evolves. The
underlying practices — lean context, protected caches, matched model capability, automated checks — are more
stable. When a specific number looks wrong, check the official documentation. When a practice looks wrong,
it probably still holds.</p>
</div>
</section>
<section class="part" id="reading">
<div class="part-head">
<div class="part-badge">R</div>
<div>
<div class="part-kicker">Reference</div>
<h2>Reading List</h2>
</div>
</div>
<div class="readgrid">
<div>
<h4>Official Documentation</h4>
<ul class="linklist">
<li>Claude Code: Manage costs effectively</li>
<li>Claude Code: Subagents</li>
<li>Claude Code: Hooks reference</li>
<li>Claude Code: Slash Commands and skills migration</li>
<li>Claude Code: Settings and permissions</li>
<li>Anthropic: Best practices for Opus 4.7 with Claude Code</li>
<li>Anthropic: Lessons from Claude Code: Prompt caching is everything</li>
<li>Anthropic engineering: Equipping agents with Agent Skills</li>
<li>Adaptive thinking and effort levels</li>
<li>What's new in Opus 4.7</li>
</ul>
</div>
<div>
<h4>Community Guides</h4>
<ul class="linklist">
<li>"18 Claude Code Token Management Hacks"</li>
<li>Claude Code Token Optimization: Stop the $1,600 Bill</li>
<li>Stop Wasting Tokens: Optimize Claude Code Context by 60%</li>
<li>ClaudeFast: Context window guide and Opus 4.7 best practices</li>
<li>How Prompt Caching Actually Works in Claude Code</li>
<li>Sub-Agents in Claude Code (when they actually save tokens)</li>
<li>Claude Code Skills: The 98% Token Savings Architecture</li>
<li>Effort, Thinking, and How Opus 4.7 Changed the Rules</li>
</ul>
</div>
</div>
</section>
<section class="wrap" style="padding-top:20px">
<div class="cta-strip">
<div class="k">
<span class="eyebrow">Next step</span>
<h3>Turn AI-assisted engineering into measurable value — without adding risk.</h3>
<p>This playbook was built on direct engineering experience with Claude Code in production
workflows. If your team is working through these problems and would find an outside perspective
useful, Akvelon's engineers work on this directly.</p>
<div class="row">
<a class="btn btn-white" href="https://akvelon.com/contact-us/">Let's talk</a>
<a class="btn btn-ghost-w" href="https://akvelon.com/homepage-ai-maturity/">Start the AI maturity
assessment</a>
</div>
</div>
</div>
</section>
</main>
</div>
<section class="about">
<div class="wrap">
<div class="about-kicker">About Akvelon</div>
<h3>Built from production experience, not theory.</h3>
<p>This playbook was built on direct engineering experience with Claude Code in production
workflows across projects of varying scales and levels of complexity. Akvelon engineers use
AI-assisted development tooling as a standard part of their delivery practice.</p>
<div class="why" style="margin:30px 0 26px">
<h5>Why Akvelon</h5>
<ul>
<li><b>50+ AI-powered projects</b> delivering measurable ROI</li>
<li><b>Full AI lifecycle support</b> — from strategy to deployment</li>
<li><b>Industry-leading AI expertise</b> across fintech, healthcare, e-commerce</li>
<li><b>Security-first builds</b> with built-in compliance controls</li>
</ul>
</div>
<a class="btn btn-primary" href="https://akvelon.com/contact-us/">Reach the AI-Assisted Engineering practice</a>
</div>
</section>
<footer class="site">
<div class="wrap">
<div class="foot-links">
<a href="https://akvelon.com/about-us/">About Us</a>
<a href="https://akvelon.com/privacy-policy/">Privacy Policy</a>
<a href="https://akvelon.com/cookie-policy/">Cookie Policy</a>
<a href="https://akvelon.com/careers/">Careers</a>
<a href="https://akvelon.com/contact-us/">Contact Us</a>
</div>
<p class="foot-tag">2026 <b>AKVELON</b> Inc. All Rights Reserved. Learn more about how we can power your
engineering advantage by bridging the talent gap.</p>
<div class="socials"><a href="https://www.facebook.com/Akvelon" aria-label="Facebook" target="_blank"
rel="nofollow"><svg viewBox="0 0 24 24" fill="currentColor">
<path
d="M13 22v-8h3l.5-4H13V8c0-1.1.3-1.8 1.9-1.8H17V2.7C16.6 2.6 15.4 2.5 14 2.5c-2.8 0-4.7 1.7-4.7 4.9V10H6v4h3.3v8H13z" />
</svg></a><a href="https://twitter.com/AkvelonInc" aria-label="X" target="_blank" rel="nofollow"><svg
viewBox="0 0 24 24" fill="currentColor">
<path
d="M18.9 2H22l-7.3 8.3L23.2 22h-6.6l-5.2-6.7L5.5 22H2.4l7.8-8.9L1.6 2h6.8l4.7 6.2L18.9 2zm-1.2 18h1.8L7.1 3.8H5.2L17.7 20z" />
</svg></a><a href="https://www.instagram.com/akveloninc" aria-label="Instagram" target="_blank"
rel="nofollow"><svg viewBox="0 0 24 24" fill="currentColor">
<path
d="M12 2.2c3.2 0 3.6 0 4.9.1 1.2.1 1.8.3 2.2.4.6.2 1 .4 1.4.9.5.4.7.8.9 1.4.1.4.3 1 .4 2.2.1 1.3.1 1.7.1 4.9s0 3.6-.1 4.9c-.1 1.2-.3 1.8-.4 2.2-.2.6-.4 1-.9 1.4-.4.5-.8.7-1.4.9-.4.1-1 .3-2.2.4-1.3.1-1.7.1-4.9.1s-3.6 0-4.9-.1c-1.2-.1-1.8-.3-2.2-.4-.6-.2-1-.4-1.4-.9-.5-.4-.7-.8-.9-1.4-.1-.4-.3-1-.4-2.2C2.2 15.6 2.2 15.2 2.2 12s0-3.6.1-4.9c.1-1.2.3-1.8.4-2.2.2-.6.4-1 .9-1.4.4-.5.8-.7 1.4-.9.4-.1 1-.3 2.2-.4C8.4 2.2 8.8 2.2 12 2.2zm0 3.2A6.6 6.6 0 1 0 12 18.6 6.6 6.6 0 0 0 12 5.4zm0 10.9A4.3 4.3 0 1 1 12 7.7a4.3 4.3 0 0 1 0 8.6zm6.9-11.2a1.5 1.5 0 1 1-3.1 0 1.5 1.5 0 0 1 3.1 0z" />
</svg></a><a href="https://www.youtube.com/@Akvelon_Inc" aria-label="YouTube" target="_blank"
rel="nofollow"><svg viewBox="0 0 24 24" fill="currentColor">
<path
d="M23 7.5a3 3 0 0 0-2.1-2.1C19 4.9 12 4.9 12 4.9s-7 0-8.9.5A3 3 0 0 0 1 7.5 31 31 0 0 0 .5 12 31 31 0 0 0 1 16.5a3 3 0 0 0 2.1 2.1c1.9.5 8.9.5 8.9.5s7 0 8.9-.5a3 3 0 0 0 2.1-2.1c.4-1.9.5-4.5.5-4.5s0-2.6-.5-4.5zM9.8 15.3V8.7l5.7 3.3-5.7 3.3z" />
</svg></a><a href="https://www.linkedin.com/company/akvelon/" aria-label="LinkedIn" target="_blank"
rel="nofollow"><svg viewBox="0 0 24 24" fill="currentColor">
<path
d="M20.4 20.4h-3.5v-5.6c0-1.3 0-3-1.9-3s-2.1 1.4-2.1 2.9v5.7H9.4V9h3.4v1.6h.1c.5-.9 1.6-1.9 3.4-1.9 3.6 0 4.3 2.4 4.3 5.5v6.2zM5.3 7.4a2 2 0 1 1 0-4.1 2 2 0 0 1 0 4.1zM7.1 20.4H3.6V9h3.5v11.4zM22.2 0H1.8C.8 0 0 .8 0 1.7v20.6c0 .9.8 1.7 1.8 1.7h20.4c1 0 1.8-.8 1.8-1.7V1.7c0-.9-.8-1.7-1.8-1.7z" />
</svg></a></div>
</div>
</footer>
<button class="totop" aria-label="Back to top" onclick="window.scrollTo({top:0,behavior:'smooth'})"><svg
viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"
stroke-linejoin="round">
<path d="m18 15-6-6-6 6" />
</svg></button>
<script>
// mobile drawer close on link click
document.querySelectorAll('.drawer-panel a[href^="#"]').forEach(a => {
a.addEventListener('click', () => document.querySelector('.drawer').classList.remove('open'));
});
document.querySelector('.drawer').addEventListener('click', e => {
if (e.target.classList.contains('drawer')) e.target.classList.remove('open');
});
// copy code
function copyCode(btn) {
const pre = btn.closest('.code').querySelector('pre');
const text = pre.innerText;
navigator.clipboard.writeText(text).then(() => {
const span = btn.querySelector('span'); const old = span.textContent;
btn.classList.add('copied'); span.textContent = 'Copied';
setTimeout(() => { btn.classList.remove('copied'); span.textContent = old; }, 1600);
}).catch(() => {
const r = document.createRange(); r.selectNode(pre);
const s = window.getSelection(); s.removeAllRanges(); s.addRange(r);
try { document.execCommand('copy'); } catch (e) { }
s.removeAllRanges();
const span = btn.querySelector('span'); span.textContent = 'Copied';
setTimeout(() => span.textContent = 'Copy', 1600);
});
}
// checklist tabs
document.querySelectorAll('.tab').forEach(tab => {
tab.addEventListener('click', () => {
const id = tab.dataset.tab;
document.querySelectorAll('.tab').forEach(t => t.classList.toggle('active', t === tab));
document.querySelectorAll('.panel').forEach(p => p.classList.toggle('active', p.dataset.panel === id));
});
});
// checklist persistence + progress (namespaced by panel)
function progressFor(panel) {
const boxes = [...document.querySelectorAll('.panel[data-panel="' + panel + '"] .chk input')];
const done = boxes.filter(b => b.checked).length;
const note = document.querySelector('[data-progress="' + panel + '"]');
if (note) note.textContent = done + ' of ' + boxes.length + ' complete';
}
function keyFor(panel) { return 'akv-playbook-' + panel; }
function restore(panel) {
let saved = {};
try { saved = JSON.parse(localStorage.getItem(keyFor(panel)) || '{}'); } catch (e) { }
document.querySelectorAll('.panel[data-panel="' + panel + '"] .chk input').forEach((b, i) => {
b.checked = !!saved[i];
});
progressFor(panel);
}
function persist(panel) {
const state = {};
document.querySelectorAll('.panel[data-panel="' + panel + '"] .chk input').forEach((b, i) => { state[i] = b.checked; });
try { localStorage.setItem(keyFor(panel), JSON.stringify(state)); } catch (e) { }
progressFor(panel);
}
['dev', 'lead'].forEach(panel => {
restore(panel);
document.querySelectorAll('.panel[data-panel="' + panel + '"] .chk input').forEach(b => {
b.addEventListener('change', () => persist(panel));
});
});
document.querySelectorAll('[data-reset]').forEach(btn => {
btn.addEventListener('click', () => {
const panel = btn.dataset.reset;
document.querySelectorAll('.panel[data-panel="' + panel + '"] .chk input').forEach(b => b.checked = false);
persist(panel);
});
});
// TOC scrollspy
const spyTargets = [...document.querySelectorAll('.part[id], .sec[id]')];
const tocLinks = [...document.querySelectorAll('.toc a[href^="#"]')];
const linkFor = {}; tocLinks.forEach(a => linkFor[a.getAttribute('href').slice(1)] = a);
const spy = new IntersectionObserver((entries) => {
entries.forEach(en => {
if (en.isIntersecting) {
tocLinks.forEach(a => a.classList.remove('active'));
const l = linkFor[en.target.id];
if (l) {
l.classList.add('active');
// also light up parent part link
const parentLi = l.closest('.sub'); if (parentLi) {
const pl = parentLi.previousElementSibling; if (pl && pl.tagName === 'A') pl.classList.add('active');
}
}
}
});
}, { rootMargin: '-20% 0px -70% 0px', threshold: 0 });
spyTargets.forEach(t => spy.observe(t));
// to-top
const totop = document.querySelector('.totop');
window.addEventListener('scroll', () => {
totop.classList.toggle('show', window.scrollY > 700);
}, { passive: true });
// animate charts into view
const chartObs = new IntersectionObserver((entries) => {
entries.forEach(en => { if (en.isIntersecting) { en.target.classList.add('in'); chartObs.unobserve(en.target); } });
}, { threshold: .25 });
document.querySelectorAll('.chart').forEach(c => chartObs.observe(c));
</script>
</div>

This whitepaper is already on its way to your mailbox!