Every time you leave the codebase for a fundraising sprint or a customer call block, you pay a re-entry tax when you come back. The mental model has decayed. You spend the first hour re-orienting. Over a year, this adds up to weeks.
The mechanism
Memory decay. Architecture decisions from last month feel fuzzy. You re-read code you wrote to remind yourself what it does.
State reconstruction. Where did you leave off? What’s broken? What was the next step? You’re paying this every re-entry.
Short session bias. When re-entry is expensive, you prefer small tasks. You knock out bugs instead of the architectural work. The important things get deferred.
Over time, this creates a codebase shaped by the gap between your mental model and reality.
Why longer coding blocks don’t fix it
Even a four-hour block starts with re-entry cost. And the deeper problem: you’re trying to hold the whole codebase in your head, alone. A 100k-line codebase with five active areas can’t fit in one person’s working memory across context switches. That’s the solo engineer ceiling.
The absence tax
The cost isn’t paid immediately. It’s paid the first time you change something you haven’t touched in a while. You underestimate the time. You introduce a regression. You’re confused about why a test is failing.
Software isn’t static knowledge. It’s living context: a web of decisions, tradeoffs, and “I’ll fix this later” notes that only makes sense if you were there when it was built. Step away, and the context decays without the code changing at all.
That’s the absence, collecting interest. And every week you’re running the company instead of writing code, the interest grows.
What it actually costs
There’s no invoice for context-switching tax. The cost shows up as: a release that slips a week, a feature that takes three times as long as it should, a bug that introduces a regression because you forgot why that code was there.
You don’t track it. You attribute it to the problem being hard, or the codebase being messy, or just “engineering taking time.” But a large fraction of it is re-entry cost. Repeated. On every file you haven’t touched in two weeks.
The asymmetry
The tax compounds asymmetrically. The more you need to leave the codebase —to fundraise, to close customers, to handle operations —the worse the decay. The founders who can least afford the re-entry cost are the ones paying it most often.
Senior engineers solve this by specializing. They stay deep in one area for months. They don’t context-switch between sales and architecture in the same afternoon. That option doesn’t exist when you’re the only technical person and you’re also running the company.
What doesn’t fix it
Batching calls. Protecting mornings for coding. Leaving yourself breadcrumbs in Notion. It all helps at the margin.
But the core problem doesn’t go away: one person trying to hold the context of a growing codebase while also doing everything else the business requires. The context decays. The re-entry tax accrues.
The founders who feel this most aren’t bad engineers. They’re engineers who are also running companies. The ceiling isn’t competence. It’s attention.