The Comprehension Budget

Every builder knows that feeling now. It arrives faster than it used to.

At the Handmade Network's 2026 expo, someone stood up and demoed a text editor written in C — a language most of the industry filed under "legacy" a decade ago — and made an argument that lands harder in 2026 than it would have in 2016. They chose C not despite the friction but because of it. C keeps the whole stack inside one head: no hidden allocations, no framework doing things you didn't ask for, no generated layers you never read. Every line is one you could have written, and therefore one you can hold.

It's easy to hear that as nostalgia, or masochism dressed up as principle. It isn't. It's a claim about ownership — and it's worth taking seriously even if you never write a line of C.

i · comprehension vs. capability

Here's the trade the handmade argument surfaces. Modern tooling — and now AI most of all — sells you capability: the power to ship things faster than you understand them. You describe what you want, the layers appear, the demo works. What you bought was output. What you didn't buy was comprehension.

The handmade choice inverts the deal. It's slower. You write the allocator, the parser, the render loop. In exchange, there is nothing in your program you can't explain. You traded speed for sovereignty over your own stack.

Neither side is free, and the pitch usually hides the bill. The cost of capability isn't paid at ship time — it's paid later, and it compounds. Opacity stacks. The layer you didn't understand sits on another layer you didn't understand, and one day the thing breaks in the seam between them. Now you can't fix it, because fixing requires a mental model you never built. You've become a tenant in your own codebase: you live there, but you don't own it, and you can't renovate.

That's the real shift in 2026. It was always possible to ship code you didn't understand. What's new is the rate. AI can generate more opacity in an afternoon than a team used to accumulate in a quarter. The gap between what you run and what you comprehend widens by default, silently, unless you decide otherwise.

ii · the purity trap

So write everything by hand? No. That's the other failure mode, and it's just as expensive.

You can't hand-forge the entire stack. You didn't write your kernel, your TCP implementation, your compiler's optimizer — and you shouldn't. Comprehension is finite. Spend it trying to understand everything and you'll ship nothing. The purist who reimplements the world isn't sovereign; they're just broke in a different currency.

Taken as "always write C," the handmade argument is a purity trap. Taken as a question, it becomes the most useful tool on your bench:

Which layers do you need to be able to hold in your head — and which can you rent?

That's the reusable idea. Not the language. The dial.

iii · the comprehension budget

Treat comprehension like what it is: a budget. You have a finite amount, and every layer you take responsibility for spends some of it. The skill isn't maximizing comprehension or minimizing it — it's allocating it on purpose.

Here's how to set the dial. You can do this on your current project tomorrow.

1. Name your load-bearing layers. For each part of your stack, ask one question: if this breaks at 3 a.m., do I need to be the one who fixes it? If yes, it's load-bearing. Load-bearing layers you own by hand — you read every line, you can rebuild them from scratch. This set is usually smaller than you fear: the core logic that is your thing, the part no library will ever ship for you.

2. Rent the rest, deliberately. Everything else, you rent — from a library, a framework, an AI. Renting is fine. Renting is necessary. The word that matters is deliberately: you know you're renting, you know what you'd lose if the rental failed, and you've decided that loss is bounded and acceptable. The database driver you didn't write is a rental you can live with. The core algorithm your product depends on is not.

3. Watch the tripwire. One signal tells you you've overspent: you can no longer form a mental model of why your own system works. When you catch yourself saying "I'm not sure why, but it works" about a layer that matters — stop. You've drifted past your budget. Re-comprehend it or replace it with something you can hold. That sentence is a smoke alarm. Don't silence it.

iv · using ai without going blind

AI-generated code isn't the enemy here — opacity you didn't choose is. You can use the fastest tools on the market and stay sovereign, if you keep comprehension in the loop:

• Read it like a PR from a stranger. Never commit a generated line you haven't read and understood. The AI is a contributor, not an authority. Review it like one.
• Apply the rebuild test from Step 1. You already named your load-bearing layers; now aim the same question at every layer the AI hands you. If a generated layer is load-bearing and you couldn't rewrite it from scratch, you don't own it yet — you're just holding it.
• Keep the boundary explicit. Write down, somewhere real, the line between what you understand and what you're renting. A comment, a doc, a README section. An invisible comprehension boundary drifts. A written one holds.

v · the dial is yours

The Handmade Network isn't really selling C. They're refusing to let the boundary between comprehension and opacity get set for them by whatever happens to be fastest. That's the move worth stealing.

You don't have to choose between shipping and understanding. You have to choose where the line goes — which layers you hold in your head, and which you rent — and then defend it on purpose. Coherenceism has a name for this one layer up: own the layer, rent the brain. Own the thin part that's actually yours; rent the compute, the libraries, the generated scaffolding. It's the same principle for a personal operating system and for a text editor written by hand: you stay sovereign not by building everything, but by knowing exactly what you must be able to build.

The opacity will compound whether or not you're paying attention. The only real question is whether you set the dial — or let it drift to zero.