← articles

Claude Code Field Guide For My Foggy Neurodivergent Mind

My personal reference for working with Claude Code — context management + the full build workflow. Written to skim, not to read cover to cover.

TL;DR (read this if nothing else)

  1. One session = one phase. Design, architecture, build, review, deploy — each gets its own session. /clear between them.
  2. Spec before code. Interview → SPEC.md → fresh session → build from the spec.
  3. Delegate reading to subagents. Never let exploration eat your main context.
  4. Give Claude something to check itself against — a test, a screenshot, an expected output. No check = no "done."
  5. Two failed corrections = stop and /clear. Don't fight a polluted session.
  6. Log as you go. ENGINEERING_LOG.md every session. BIP.md every milestone.

Why This Matters (the one-paragraph version)

Claude Code re-sends your entire conversation with every message. A session open for hours costs full context on even a one-line question — and quality drops as the window fills, not just cost. So the game isn't "fit more in." It's keep sessions small and make handoffs between them cheap.

The Build Workflow (SDLC, mapped to Claude Code)

Think of this as a relay race. Each leg is its own session. Don't run the whole race in one.

1. Design & Requirements

New session. Plan mode on (Shift+Tab).

Don't let Claude jump to code. Make it interview you first:

I want to build X. Interview me in detail using the AskUserQuestion tool —
implementation, UI/UX, edge cases, tradeoffs. Keep going until we've
covered everything, then write a complete spec to SPEC.md.

A good spec: names the files/interfaces involved, states what's out of scope, ends with a way to verify it worked.

2. Architecture

New session. Read the spec, ask for the module boundaries / data flow / patterns, write to ARCHITECTURE.md.

For a real decision (e.g. Postgres vs. Mongo) → use the engineering:architecture skill. It writes a proper ADR (decision + trade-offs + consequences), not just an opinion.

3. Implementation

Fresh session per phase. /clear, load only SPEC.md + ARCHITECTURE.md, then work the loop:

Explore → Plan → Implement → Commit

  • Skip planning only if you could describe the diff in one sentence.
  • Delegate reads: "use a subagent to check how auth handles refresh tokens" — keeps 40 files of exploration out of your main window.

4. Testing

Write the check before asking Claude to call it done. Give it example cases in the prompt.

Use the engineering:testing-strategy skill when planning coverage for a new module.

5. Code Review

Fresh eyes, zero shared context. Spin up a subagent or use the engineering:code-review skill:

Review this diff against SPEC.md. Flag correctness gaps only — not style.

A reviewer that watched you write the code is biased toward agreeing with it. A fresh one isn't.

6. Deploy

Run engineering:deploy-checklist before shipping — migrations, feature flags, rollback triggers, CI status. Two minutes now, saves a 2am page later.

7. Iterate / Incident

  • Something's broken → engineering:debug (reproduce → isolate → diagnose → fix)
  • Something's on fire → engineering:incident-response

Context Management Toolkit

Habits (do every session)

Habit Why
/rename before /clear So you can find the session again with /resume
/clear between unrelated tasks Stale context costs tokens on every message after it
/compact <focus> instead of letting auto-compact fire You control what survives the summary
Use subagents for research Their reading stays in their window, not yours
Two failed corrections → /clear + rewrite prompt A clean session + better prompt beats a polluted long one
/btw for side questions Answer never enters conversation history

Config (set up once, benefits forever)

Setting What it does
/context Shows exactly what's eating your window right now
CLAUDE.md under ~200 lines It loads every session — keep it to commands + conventions only
Move detailed workflows into .claude/skills/ Skills load on demand, not every session
/mcp → disable unused servers Each active server costs context
Prefer CLI tools (gh, aws, supabase) over MCP equivalents Zero context cost until called
PreToolUse hook to filter verbose output e.g. grep test output down to failures only, before Claude sees it
/model → Sonnet for routine work, Opus for architecture Match cost to task complexity

Failure Patterns (spot these early)

Pattern What it looks like Fix
Kitchen sink session One task, then an unrelated ask, then back to the first /clear between tasks
Correcting on loop Wrong → correct → still wrong → correct again After 2 corrections, /clear + rewrite the prompt
Bloated CLAUDE.md Claude ignores half your rules Prune ruthlessly; move specifics to skills
Trust-then-verify gap Looks done, isn't Always demand a test/screenshot/output as evidence
Infinite exploration "Investigate X" with no scope → reads 200 files Scope it narrowly, or hand it to a subagent

Subagents — Quick Explainer

A subagent is Claude working in its own separate context window, off to the side of your main conversation. It does the reading/searching/verbose work, then reports back a summary — the raw output never touches your main window.

When to use one:

  • Researching a codebase before you build ("how does token refresh work here?")
  • Running tests / processing logs (verbose output stays in their window)
  • Reviewing your own work with fresh eyes (no bias from having written it)

How to trigger one: just ask —

Use a subagent to investigate how our authentication system handles
token refresh, and whether we have existing OAuth utilities to reuse.

Custom subagents (for repeat use) live in .claude/agents/ as a markdown file with a role, allowed tools, and instructions. Claude can write these for you — just ask.

Command Cheat Sheet

Command Use it for
/clear Wipe context, start fresh (free — costs nothing)
/compact <focus> Summarize now, keeping what you specify
/context See what's using your context window
/rewind (or Esc Esc) Undo conversation and/or code to a checkpoint
/rename Name a session before clearing, so you can find it later
/resume Pick up a named session
/model Switch Sonnet ↔ Opus mid-session
/effort Lower reasoning effort for simple tasks
/mcp See + disable MCP servers
/init Generate a starter CLAUDE.md
/doctor Diagnose CLAUDE.md bloat / setup issues
/btw Ask a side question that won't enter history
AskUserQuestion tool Have Claude interview you before building

My Standing Practices

(Personal reminders — keep doing these)

  • ENGINEERING_LOG.md — updated at the end of every session: decisions, mistakes, why, lessons learned. This is what makes the next session (or future-me) fast to re-onboard.
  • BIP.md — a LinkedIn-ready post drafted at every milestone. Ties naturally to session boundaries: close a phase, write the post, move on.
  • Set architecture and phase boundaries myself; let Claude Code run autonomously within them.
  • Catch quality issues actively (tight coupling, self-referential test assertions) — don't just trust the diff.

Reference this before starting any new build phase. If a session starts feeling foggy or off-track, that's the signal to /clear and come back to this doc.

Comments
← back to articles