Build Yourself an Exocortex: End the Daily Groundhog Day With a Genius

Boston, 1953. The neurosurgeon William Scoville leans over a twenty-seven-year-old patient named Henry Molaison and removes a piece of his brain the size of two fingers — the hippocampus on both sides, to stop the epilepsy that wouldn't let the man live. The seizures recede. And with them recedes Henry's ability to remember anything for longer than a minute. For the next fifty-five years he will be studied by the neuropsychologist Brenda Milner. Fifty-five years. And every single time she walks into the room, she is a new stranger to him — he greets her as if they are meeting for the first time.

In the science of memory he will live on as "patient H.M." — the single most important case in the history of memory. But the cruellest detail isn't that Henry forgot. It's that he was smart. Sharp, witty, in every single second a fully present adult man. Milner even taught him to trace a figure while looking only in a mirror — a hard skill, where the hand fights its own reflection. Every day he got better at it. And every day he swore he was seeing the exercise for the first time. The mastery grew. The memory of ever having practised did not.

For a long time I couldn't place who this story reminded me of. Then one morning I opened a new chat with Claude, explained for the third time that week how my project is built, what my conventions are, what I do NOT want — and caught myself thinking: I am Brenda Milner. Every morning I walk into a room with a genius who doesn't remember we've known each other for five months.

Steve Yegge, an engineer with three decades behind him, named it bluntly: the agent's "dementia problem" — it loses context between sessions that last "about ten minutes." Technically your agent's working memory is 200,000 tokens, but quality drops once it's ~60% full (engineers call it context rot). So it forgets not only overnight. It forgets mid-conversation. An amnesiac genius who re-introduces himself to you — and sometimes to himself — within a single working session.

Why this suddenly became a problem now

A year ago this was a curiosity for enthusiasts. Now it's the default mode. Boris Cherny, the creator of Claude Code, stopped writing code by hand entirely in October 2025: the model does 100%. More than one in five code reviews on GitHub now involve an agent. "Forward deployed engineer" jobs — people who embed AI into clients' live products — grew by more than 800% over nine months of 2025. A marginal tool became infrastructure. And when a tool becomes infrastructure, its hidden defect stops being a curiosity and becomes your daily tax return.

Here's the number to start with, because without it the rest is just a mood. The engineer Kyle Redelinghuys kept a ledger for eight months: he ran roughly 10 billion tokens through Claude Code. At API rates that would have cost over $15,000. He paid around $800 — on a Max subscription. Where's the 93% discount from? Over 90% of his tokens were cache reads — re-reading the same context. The machine that should have cost fifteen thousand cost eight hundred, because the same context wasn't reinvented each time — it was reused.

Hold that number in mind, because it's the key to this whole guide. The most expensive thing in working with AI isn't tokens. Tokens get cheaper: the Opus flagship fell ~67% over the last generation (from $15/$75 to $5/$25 per million). The most expensive thing is the compounding you didn't write down. Every session that ends with nothing but a result is Henry, who once again doesn't remember he's already traced this figure.

The antagonist: the operator who keeps the genius amnesiac

Let's name the antagonist, because without a face this is a lecture, not a mirror. The antagonist of this text is not Claude or ChatGPT. They're excellent. The antagonist is the Vending-Machine Operator: someone who treats AI like a coffee machine. Drop in a prompt — get a result — walk away. Tomorrow, drop another, explain again who he is, what the project is, what he dislikes. He confuses motion with accumulation. It feels like work because his fingers are busy — but really he rolls the same boulder of context uphill every morning, only to watch it roll back down at /clear by evening.

And here's the question worth asking: who benefits from you staying a Vending-Machine Operator? Because none of this is an accident. Vendors monetise the feeling of productivity, not measured outcomes: it's profitable for you to re-hire the genius every morning, because each new "introduction" is tokens, subscriptions, upgrades. The research group METR found something brutal in the summer of 2025: developers worked 19% slower with AI — yet were convinced they were 20% faster. The speedometer is broken in the pleasant direction. You feel a climb while you're stalling. The benefit is socialised among those who sell the engine; the risk of degradation is privatised onto you.

So this entire guide is a tool against one specific arrangement: where your endless willingness to re-explain everything is most profitable for everyone except you. And here is the thesis the rest rests on:

Symbiosis is accelerated not by a smarter model, but by the memory, the reflex and the verifier you build around it — and almost all of them are free. Money buys throughput and parallelism, not symbiosis.

Engineers already have a name for it. Birgitta Böckeler of Thoughtworks puts it as: Agent = Model + Harness. The harness is "everything in an AI agent except the model itself": memory, instructions, hooks, tests, loops. You rent the model. You build the harness. And it's the harness that decides whether your genius is Henry Molaison or an exocortex — an external cortex that remembers for him.

Below are nine loops of that exocortex, from the cheapest and most important to the hardware. First the map, then each loop.

Loop 1. Memory and the end-of-session reflection ritual

The cheapest loop and the most important. It's literally free, and it's the difference between Henry and an exocortex.

An agent's memory today stands on two floors. The first is static: files you write yourself that load every session. In Claude Code that's CLAUDE.md; across the rest of the ecosystem it's the vendor-neutral AGENTS.md (already used by over 60,000 GitHub projects, a standard under the Linux Foundation). It's a constitution: who you are, your conventions, what NOT to do. The second floor is automatic: memory the model writes for itself. Claude Code, from version 2.1.59, keeps its own MEMORY.md plus topic files in the project folder and loads the first 200 lines each session; OpenAI Codex has "Memories" that self-summarise idle threads. At the API level there's a dedicated memory tool (six operations over a /memories folder) — and when it's on, Anthropic injects a system-prompt line that gives you a chill: "ASSUME INTERRUPTION: your context window might be reset at any moment." The machine is taught to live as if it were H.M. — and to take notes while it still remembers.

The data leaves no room for doubt. On Anthropic's internal eval, memory together with context editing gave +39% to agentic-search quality; on a 100-step task, context editing cut token consumption by 84% and let runs finish that would otherwise have collapsed from overflow. Memory isn't a convenience. It's the difference between "made it" and "stalled."

But the real lever isn't a file — it's a ritual. A session should end not with a result but with reflection. It's a separate, cheap, automated event — in Claude Code terms you hang it on the Stop hook (fires when the agent finishes). Here are three maturity levels of that ritual, from manual to self-teaching.

And don't confuse "more memory" with "better memory." Anthropic's own playbook insists: store distilled lessons and structured summaries, not the raw transcript. Keep CLAUDE.md under 200 lines — "a bloated CLAUDE.md makes Claude ignore your actual instructions." Memory isn't a warehouse, it's a library with a ruthless librarian. Borges's Funes, who remembered absolutely everything — every leaf of every tree — was not a genius but a cripple, unable to think, because to think is to forget the trivial. H.M. and Funes are the two walls of a corridor. Symbiosis is the narrow path between them.

Memory system	Who writes	Local/cloud	Price	For what
CLAUDE.md / AGENTS.md	you	file in repo	free	the constitution: rules, conventions, "don't"
Auto-memory (Claude Code)	the model	local	free	self-written patterns, build commands, insights
Memory tool (API)	the model	you host	tokens	facts outside the context window; survive compaction
claude-mem	plugin	local (SQLite+vectors)	free, OSS	session compression, ~10× token savings, multi-IDE
Beads (bd, Steve Yegge)	the agent	git (JSONL)	free, OSS	issue tracker as memory; dependencies; vs "dementia"
Cline Memory Bank	methodology	6 .md files	free	structured memory that rebuilds context on a fresh session

Refrain one, note it down: the genius doesn't get cheaper — the memory you fail to keep for him does.

Loop 2. A system that builds its own skills, commands and crons

Memory remembers facts. The next loop remembers actions — and turns them into reflexes. This is the direct answer to the request: a system that doesn't just surface insights but proactively proposes new skills, modules, crons, commands.

The mechanism is called the maturation ladder, and it already works in open source (most clearly in the continuous-learning-v2 set). The logic:

While full maturation autonomy is still the frontier (Anthropic's roadmap openly states the hope "to enable agents to create, edit, and evaluate Skills on their own"), there's a simple, foolproof heuristic worth wiring in today. The engineer Sankalp put it: wrote a prompt twice — turn it into a command. The third time isn't work, it's debt. A command lives in .claude/commands/ (project) or ~/.claude/commands/ (global).

And how does a skill differ from the constitution? In the economics of context. CLAUDE.md always loads — so every extra line eats the budget each session. A skill (the SKILL.md format) works by progressive disclosure: at startup only its name+description fly into memory (a few dozen tokens), the full body only when a task genuinely matches, and the scripts on demand. Simon Willison, one of the field's most attentive voices, predicts a "Cambrian explosion in Skills that will make this year's MCP rush look pedestrian by comparison." Why: a simple idea scales, a complex one doesn't.

And the last, sharpest detail of this loop. Text advises — a hook enforces. CLAUDE.md is followed about 80% of the time (it's an instruction delivered as a user message, no guarantee). A hook is 100%: it intercepts a tool call and can block it with exit code 2. So the rule: anything that must happen every time (lint, format, security, test) — don't ask, wire it into a hook. Disler built the reference observability panel that catches all 12 hook lifecycle events into a live dashboard — so you can see which workflows repeat most and codify exactly those into skills. First see the repetition. Then turn it into a reflex.

Loop 3. Fewer iterations to acceptable

This is the core of the request: fewer iterations to a good result, less and less polishing. Three levers here, and all three are about one thing — front-loading: moving the disagreement and the checking to before the code is written, not after.

Lever A. Context engineering

The context window is the most important resource you manage, and it drains fast. Practices:

• An attention budget. Keep CLAUDE.md under 200 lines; "brevity is a performance requirement." Run /context to see where the window goes, and /memory to debug which files loaded.
• The two-mistakes rule. Corrected the agent twice on the same thing — the context is already polluted with failed approaches. Don't argue with it. /clear and start fresh with a better prompt.
• Subagents as context firewalls. Delegate the heavy reconnaissance ("use a subagent to investigate how token refresh works in our auth") — it reads 6,000 tokens in its own separate window and returns a 400-token summary. The main conversation stays clean.
• MCP without obesity. A real case: a GitHub+Slack+Sentry stack (~40 tools) ate 143,000 of a 200,000-token window before you typed a single character. The industry rule: 4–6 sharp servers, not 15. Past ~50 visible tools the model measurably starts mis-selecting. Tool Search (in Claude Code since February 2026) saves you — on-demand schema loading, ~85–96% savings.

Lever B. Specification first, code second

Sean Grove of OpenAI puts it sharply: "80–90% of programming is structured communication," and specifications, not code, are the real unit of value. Hence two techniques. First — plan mode (Shift+Tab twice): the agent reads files and proposes a plan but edits nothing until you approve. Boris Cherny: "this easily 2–3×'s results for harder tasks." Second — the interview-to-spec: "I want to build X. Interview me in detail until we've covered everything, then write a full spec to SPEC.md." Then a fresh session executes against the spec, with no clutter from the exploration phase. Harper Reed made it canon: a "one question at a time" conversation → spec.md → a prompt plan → execution.

Lever C. Give the machine a way to check itself

Here lives the load-bearing thesis of this section. Stack Overflow named the year's top frustration outright: code that is almost right, but not quite (66%). And "almost right" is more expensive than "wrong," because the wrong you throw out in a second, while the almost-right compiles, passes your tired review — and breaks a week later in production. The cure is a deterministic gate.

Alongside: TDD Guard (blocks implementation without a failing test — because agents, as Kent Beck documented, tend to delete the failing test to make the suite green); Puppeteer/Chrome DevTools MCP (the agent sees its own work in the browser — another "2–3×" per Cherny); eval-driven development (write the grader first, then the code). An academic proof of the power of context: the TDAD method (feeding the agent which tests matter via a dependency graph) raised SWE-bench resolution from 12% to 60% over 15 iterations with 0% regressions. And the counter-intuitive "TDD paradox": just telling an agent to "do TDD" with no context about which tests matter worsened the result (regressions from 6% to 10%). Context beats instruction.

Lever (fewer iterations)	Mechanism	Effect	Price	To set up
Plan mode (Shift+Tab ×2)	disagreement into text before code	2–3× on hard tasks	free	0 min
Self-check loop (Puppeteer/tests)	the agent sees its own work	2–3× quality	free	20 min
3-layer verify (lint+Stop-test)	a deterministic gate	−20–30% rework	free	~20 min
TDD Guard	no code without a failing test	less "deleted the test"	free	10 min
Interview→SPEC.md→fresh session	a contract before code	catches scope creep	free	30 min
CLAUDE.md ≤200 lines	every repeated mistake = 1 line	~60% commit-ready first try	free	gradually
Context7 (live docs)	fresh version-specific docs in the prompt	kills stale-API hallucinations	free/€	5 min
Cross-agent review	a different agent reviews	2–3× ("the author is the worst reviewer")	model	0 min

Refrain two: the machine made writing cheap. Verification became the most expensive thing.

Loop 4. Autonomy: crons, background agents, the night shift

Once memory, reflex and verification are in place, the agent can be let loose — on a schedule and without you. This is the direct request about crons. A whole ladder has appeared here, from "machine on" to "machine off."

The specifics worth knowing:

• Headless as a primitive. claude -p "prompt" — one non-interactive run to stdout. With --output-format json the response carries total_cost_usd; with --max-budget-usd 0.50 and --max-turns 10 — autonomy with a spending ceiling. This makes nightly crons safe: you know the maximum bill in advance.
• The Ralph loop (Geoff Huntley): a bare while :; do cat PROMPT.md | claude-code ; done. The state isn't chat history but the codebase itself; context resets each iteration, one thing at a time. The reported result: a $50k MVP delivered for $297 of agent compute. The warning is documented too — "overbaking": leave the loop running too long and the agent starts inventing features no one asked for. Hygiene: once a night via cron, stop after completion.
• /babysit-pr (Jökull Sólberg): ~170 lines of markdown that shepherd a pull request from push to merge — polling CI in parallel, running codex review, triaging. The triage rule isn't blind: "Codex findings default to Fix; Greptile comments get assessed individually; CI failures always get fixed." One cycle is ~10 min, and it caught 2 real bugs Greptile missed.

And now the anomaly that shows the ceiling of the possible — and its limit at once. Boris Cherny, the creator of Claude Code, runs the most extreme documented setup: 5–10 sessions from his phone, a few hundred subagents live + "a few thousand" overnight, dozens of cron loops (three named production ones: babysit PRs, heal flaky tests, cluster feedback). The output is a few dozen PRs a day. Sounds like a superpower. But the same industry names the ceiling in chorus: human review. Armin Ronacher (creator of Flask): "it's only so much my mind can review." More on that in loop 8 and in the finale.

Loop 5. Voice: the cheapest upgrade on the human side

So far we've been fixing the machine's memory. But there's a node in the exocortex loop the Vending-Machine Operator ignores: capture — the speed at which you get context inside. And here the biggest lever isn't on the desktop, it's in your throat.

The canonical study (Stanford/Washington, authors include Andrew Ng and James Landay) showed back in 2016: voice text entry is three times faster than QWERTY, with 20% fewer errors. The modern numbers are sharper: Zack Proser dictates into Wispr Flow at 184 words a minute versus 90 on the keyboard. But speed isn't the point. The consultant Dominik Gabor framed the point: "the unlock isn't speed, it's context." Five minutes of spoken stream gives 700–800 words — and, more importantly, you say things you'd never type: stakeholder politics, prior attempts, gut feelings you'd be embarrassed to write. Voice feeds the agent a density the keyboard never gives.

Claude Code already has a built-in /voice command (the OS recognition engine, no external tools). For a permanent driver — Wispr Flow ($15/mo, or a free tier of 2,000 words/week; for private/EU data — VoiceInk, 100% local). For fully hands-free coding — Talon (the "air-bat-drum" phonetic alphabet, works even with an eye-tracker; this is how people with RSI code). Karpathy called this mode "vibe coding": "I just talk to Composer."

Loop 6. Glasses and wearables: capture without hands

The next step of capture is ambient: a device that hears your day and feeds it to the agent. There's a lot of hype here, so the main lesson all the reviews repeat, up front: the value is in the loop (capture → structure → retrieve → act), not the device. Hardware without a loop is an expensive dictaphone.

The market split into three prices. Limitless Pendant (~$199 + ~$19/mo; availability in flux after the Meta deal) — the most mature: it hosts its own MCP endpoint (api.limitless.ai/mcp), so you point Claude or ChatGPT straight at your own life and ask it in natural language. Bee ($49.99 + ~$19/mo, bought by Amazon in July 2025) — the cheapest always-on entry. Omi (~$89, fully open-source, MIT, 300k+ users, also has an MCP server) — for those who want self-hosting and ownership of their data. Plaud Note (~$159, push-to-record, no subscription, bring your own ChatGPT) — for meetings and calls. And separately Meta Ray-Ban Display: in May 2026 Meta opened the glasses to third-party developers via the Wearables Device Access Toolkit — you can deploy a web app (HTML/CSS/JS) straight onto the lens and drive it with Neural Band gestures. It's early adoption, not a working tool yet — but the vector is clear: a glanceable HUD + capture.

An honest caveat (and an example of factual discipline): the spec-sheet numbers lie. Limitless's "100 hours" of battery is ~8–10 hours of active recording; Bee's "160 hours" only holds with the phone constantly nearby over Bluetooth. Buy the loop, not the spec sheet.

Loop 7. Hardware: a second brain, a night runner, a phone remote

The desktop isn't the limit. Three hardware investments that genuinely move symbiosis:

• A second machine as a runner. While the main one is busy with you, the second runs nightly crons and parallel work. An M3 Ultra Mac Studio with 512 GB is the one "home" machine that fits models that fit nowhere else (DeepSeek R1 4-bit at 128k context); locally it's ~5× slower than the cloud, but private and persistent — for sensitive data or overnight that's a value of its own. For the GPU route: an RTX 4090 gives ~80–85% of the RTX 5090's inference throughput for ~$400–550 less (5090 ~$1,999 MSRP vs 4090 ~$1,599; the real gap is smaller than the myth).
• Driving the fleet from your phone. The official path arrived: Remote Control (/rc, since February 2026, outbound HTTPS only, no open ports). The DIY classic worth knowing: Tailscale (a WireGuard mesh, no port-forwarding) + mosh (the session survives connection loss and sleep) + tmux (the agent session doesn't die) + ntfy (hooks push to the phone on AskUserQuestion/Stop/Error events). This is "Claude Code from the beach": the fleet runs, you only get a push when you're needed.

Off-desktop investment	Price	What it buys	When it's worth it
Wispr Flow	$15/mo	184 vs 90 wpm; 5 min = 700–800 words of context	almost always — top ROI on the human side
Talon / VoiceInk	free	hands-free coding / local (EU privacy)	RSI or sensitive data
Limitless Pendant	~$199 + ~$19/mo	always-on → hosted MCP → Claude over your life	if you run a Coach loop; otherwise a phone recorder
Bee / Omi	$49.99 / ~$89	cheapest always-on / open-source self-host	to experiment with ambient capture
Plaud Note	~$159	push-to-record, BYO-ChatGPT, no subscription	meetings, calls
Meta Ray-Ban Display	HUD class	glanceable HUD + web apps (Neural Band)	early adoption; not a work tool yet
2nd machine / M3 Ultra 512GB	$$	night runner, local models, parallelism	when you run a fleet or hold sensitive data
Remote rig (/rc or Tailscale+mosh+tmux)	free	drive the fleet from your phone	when you have background agents

Loop 8. Hiring people: where a human is irreplaceable

The question was direct: invest in gadgets or in people? The disciplined answer: hire into the bottleneck. And the bottleneck has already been named in chorus — it's verification and judgement, not production.

The role of the human beside the fleet has inverted. A Salesforce agent manager describes his posture like this: "Data, data, data. I start and end my day in dashboards, scorecards and agent observability monitoring." This isn't the one who writes — it's the one who watches. And the market's key conclusion: for this role, domain/operational expertise is worth more than AI expertise. You don't need a "prompt engineer," you need someone who can tell the almost-right from the right in your specific business.

The "automate or hire" decision frame (like2byte) splits work into three buckets: AUTOMATE (AI does it reliably, only periodic checks), DELEGATE (a human VA — because AI here creates more risk than it saves time), HYBRID (AI drafts, the human judges). The bridge tactic: record yourself doing the task → transcribe with AI → generate an SOP → hand it to the VA. 2026 cost anchors: an offshore VA $500–3,000/mo; an "AI Chief of Staff" (a new role) — $200–400k/year.

And an $80M caveat. The solo founder Maor Shlomo built Base44 in 4 months with agents in the roles of PM, QA and developer — and sold it to Wix for $80M. But he shut down the support bot after two weeks: "I actually needed to do support myself to stay close to the product." Even at peak automation, a last metre remains where a human's presence isn't inefficiency but the point. More than one in five reviews on GitHub already involve an agent; a January 2026 study showed agent-written code carries more technical debt per change — so the value of a dedicated human reviewer doesn't fall, it rises.

Loop 9. The €1,000/mo budget: where it actually goes

Now the honest arithmetic, because the question was about it. And the first truth is uncomfortable for the industry: for a solo operator the pure software costs not €1,000 but ~$70–300/mo. A typical multi-tool stack — Cursor Pro $20 + Claude Pro $20 + ChatGPT Plus $20 + Copilot $10 = $70/mo. The rest is either a throughput upgrade or paranoia.

The second truth is about arbitrage. For agentic work a subscription beats the API by an order of magnitude, because 90%+ of tokens are cache reads (paid per-token on the API, effectively flat on Max). Recall Redelinghuys: a $200 Max ≈ $5,000 of API compute. The volume rule: under ~50M tokens/mo — the API is cheaper; 50–200M — Max 5x ($100); 200M–1B+ — Max 20x ($200).

Model	$/M in	$/M out	When
Opus 4.8	5	25	repo-level, 1M context, output-heavy
Sonnet 4.6	3	15	daily driver (Ronacher: Sonnet only)
Haiku 4.5	1	5	cheap subtasks, classification
GPT-5.5	5	30	terminal/DevOps, a second opinion
Cache hit	0.1× in		why a subscription beats the API in agentic work
Batch API	−50% in and out		nightly bulk runs

Now the €1,000 layout itself. I deliberately do NOT throw it all at models — that would be the "90% burned in the wrong place" mistake. The Vending-Machine Operator would spend the thousand on duplicate $100+ subscriptions that overlap, or on premium tiers he never saturates. The symbiote spends differently:

Line item	~$/mo	What it buys	Free alternative
Claude Max 20x	200	the main driver, ~$5,000 of API compute, cache-reads flat	Max 5x ($100)
Codex / ChatGPT Pro	100	a second opinion, cross-review, terminal/DevOps	Plus ($20)
Wispr Flow	15	3× input speed — the main human-side upgrade	VoiceInk / /voice (free)
Memory · skills · hooks · verification	0	compounding — the heart of symbiosis	all open-source
Context7 (live docs)	0–20	kills stale-API hallucinations	free tier
Capture device (amortized)	~20	ambient context → MCP	phone recorder (free)
Human reviewer / VA (10–20 hrs)	300–400	lifts the verification ceiling	—
API headroom for nightly fleets	100–150	Ralph / Routines / overnight	—
Hardware (amortized 2nd machine)	~80	runner, parallelism, local privacy	an old machine

The sum ≈ $830–985 ≈ €1,000. But look at the row with a zero. Memory, skills, hooks, verification — the only thing that gives compounding — costs nothing. The money in this table buys throughput (voice, a second model, API headroom, a second machine) and a human ceiling (a reviewer). It does not buy symbiosis. You assemble symbiosis by hand from free parts; the €1,000 just gives it a wider throat and a night shift.

The state, the trends and the anomalies: who's moving where

If you compress the whole frontier of 2026 into one arc: prompt engineering → context engineering → harness engineering. First we learned to write the prompt. Then to curate context. Now to build the harness (memory, hooks, tests, loops), because it — not the prompt — survives the next model release. Four theses Hacker News converges on: verification is the real bottleneck (speed is solved, trust isn't); skills beat one-off prompts; orchestration beats autonomy; workflows beat demos.

Where it moves fastest: Agent Teams (3–5 teammates, a shared task list with file locking, a mailbox for P2P comms), Dynamic Workflows (Claude writes the orchestration scripts itself; auto-triggered via "ultracode"), computer-use routed by each provider's strength, cross-agent review (a different agent reviews — "2–3× better, because the author of the code is its worst reviewer," Cherny).

Operator	Signature move (where they're at the edge)
Boris Cherny (creator of Claude Code)	thousands of agents overnight from a phone, ~150 PRs/day, 3 cron loops
Armin Ronacher (Flask)	claude-yolo in Docker, Sonnet only, a Makefile+pidfile harness; "only so much my mind can review"
Simon Willison	designing agentic loops; AGENTS.md over MCP; 6 terminals × 6 repos
Mitchell Hashimoto (Ghostty)	$15.98 per feature / 16 sessions; one session = one commit
Steve Yegge	Beads — git memory against the agent's "dementia"
Geoff Huntley	Ralph: while-true, an MVP for $297, the "overbaking" phenomenon
Peter Steinberger	~100% of code by agents on a 300k-LOC app
Birgitta Böckeler (Thoughtworks)	"harness engineering": Agent = Model + Harness

Anomalies worth knowing, because they're the edge of the Overton window: Willison at his peak held 6 terminals on 6 different repos; Kilo Code engineer Mark runs 20+ agents, mostly background "fire-and-forget," opening PRs on their own; OpenAI keeps 88 separate AGENTS.md files for subsystems of one repo; local enthusiasts stitch a DGX Spark + M3 Ultra over a 10-gigabit cable for a 2.8× speedup. And a counter-anomaly useful for the wallet: the market keeps repeating that two $20 plans ($40) often beat one $100 plan — don't buy two premium tools that overlap.

An honest objection (because without one this is a sermon)

The strongest counter-argument deserves full force, not a strawman. It goes like this, in three blows.

First: the bitter lesson. Models grow so fast that your harness rots. Every hour poured into hooks and skills is an hour the next release makes useless. Just wait and prompt. Second: METR. AI made experienced developers 19% slower — maybe all this system-building is elaborate procrastination, productivity theatre with a config file. Third: churn. The half-life of these tools is months. Brave killed its free tier in February 2026; Copilot rewrote its billing on June 1; Superwhisper raised its "lifetime" licence from $249 to $849. Building on this is building on sand.

There's force in this. And now what the objection doesn't explain. Look at what exactly dies on a model upgrade — and what doesn't.

Harness layer	Survives a model upgrade?
A clever prompt / jailbreak	✗ obsolete in one release
A fine-tune for a specific model	✗
Choice of model / provider	✗
A spec / contract (SPEC.md)	✓
Tests / a verify gate	✓
An SOP / written context	✓
Memory across sessions	✓
A skill / command (markdown)	✓ — portable across harnesses

The bitter lesson kills clever prompts and fine-tunes — exactly the layer that is the model. It does not kill your test suite, your SOP, your written memory — because that's not the model, it's the harness. And METR measured people without that harness: dropped into an unfamiliar AI flow on mature repos, with no spec, no verification gate. So −19% is the portrait of the Vending-Machine Operator. The difference between that −19% and those shipping 150 PRs a day is the harness. The objection doesn't refute the thesis. It proves it: build what survives the model, not what is the model. Yes, tools are fickle — but memory, spec and tests are portable; when Wispr gets pricier you swap the dictaphone, not the loop.

A 30-day plan: free first

A guide without a sequence is inspiration, not a tool. Here's the order in which each step makes the next one cheaper. Free first — because that's what compounds.

1. Day 0–1 (free + $15). CLAUDE.md/AGENTS.md under 200 lines. Run /memory and /context — see what actually loads. Set up voice (Wispr Flow or /voice). That's it. This already makes every future session cheaper.
2. Week 1 (free). The 3-layer verification loop (lint hook + Stop-test hook). Plan-mode discipline (Shift+Tab ×2) on anything harder than a one-line edit. The "two mistakes → /clear" rule.
3. Week 2 (free). The end-of-session reflection ritual (agent-retro or /reflect+stop.sh) writing to a memory folder. The "prompt twice → command" rule.
4. Week 3 (free). Skills for your 3 most-repeated workflows. 4–6 MCP servers max. Context7 for fresh docs.
5. Week 4 (subscription). The first cron/Routine: a nightly log triage or /babysit-pr. Headless with a --max-budget-usd ceiling.
6. Onward (as your review ceiling allows). The maturation ladder (instincts → skills). Cross-agent review. Parallel worktrees — exactly as many as your mind can review.

Notice the order? The first three weeks cost zero. The money enters only in the fourth — once the free foundation already compounds and there's something to scale.

Who walks into the room

Back to Henry Molaison. The cruellest thing about his story isn't that he was stupid. He was sharp every second: witty, warm, fully present in each separate "now." The tragedy is that nothing learned crossed midnight. He lived in an eternal present, and Brenda Milner, who knew him for half a century, walked in a stranger every morning — and he smiled at her for the first time, every time.

Your agent is H.M. Sharp, fast, memoryless. And the only question this whole guide asked is: who will you be in that room? The patient's hand, reaching at dawn for the same boulder that rolled back yesterday? Or Milner — the one who keeps the notes the patient can't hold, and builds the bridge across the nights he cannot cross alone?

The bill comes due in a currency you didn't choose. Not money — the model is cheap and getting cheaper. But the compounding you didn't write down: in the fifth explanation of the same context, in the ninth iteration of what should have taken two, in years of tracing the same figure in the mirror with no memory that the hand already knows it. The operators who carry ten times more aren't smarter than you. They simply stopped re-introducing themselves to the genius every morning.

The genius doesn't get cheaper. The memory you fail to keep for him does. The machine made writing cheap — verification became the most expensive thing. You hired a genius. All that's left is to stop firing him every night at /clear.