Cognitive Debt
It doesn’t appear in the backlog, and nobody seems to be talking about it. It’s easier to fill our Jiras with tickets than to look at what isn’t visible. Technical debt is easy to see — everyone knows how to name it, measure it, prioritize it. But I’ve been noticing something quieter, and more expensive.
It shows up when knowledge of the system lives in people, not in the system. When only someone knows why a feature works in that particular way. When changing something first requires reconstructing, mentally, how everything is connected. When business logic is scattered across decisions nobody documented. I call this cognitive debt.
And little by little, what used to live in people seems to be starting to live in AIs. That adds a new layer, because they make decisions a little removed from what we can see, and they operate on a system nobody fully understands. But there’s something else: they may also be rewriting the evidence of how that system works. Tests that get “adjusted” to pass, specs that get reinterpreted, documentation that gets regenerated. The layer that let us verify starts moving along with the code it was supposed to verify.
On top of that, something more structural: we are human. We have finite cognitive bandwidth, and this debt consumes it. It gets spent on understanding the system as it exists, not on reasoning about it. The team ends up paying a kind of constant cognitive rent, with no room left to question the system, improve it, or reimagine it.
At some point this usually gets read as a documentation problem. And yet, missing documentation is a symptom, not the cause. Behind it is a loss of conceptual coherence: there is no longer a shared mental model of how the system works. Each person builds their own partial picture of reality, and those pictures diverge.
In that context, the speed of implementation doesn’t drop because of a lack of technical ability. It drops because the cognitive cost of every decision is disproportionately high.
What I’ve been seeing help — and it’s counterintuitive — is investing in reducing complexity before adding functionality. Not as a debt waiting to be paid down, but as a deliberate decision: simplify the system to the point where the team can reason about it together again.
A system that can be reasoned about will always be more scalable than one that can’t, regardless of the size of the team.
The next competitive advantage won’t be how much code you can generate. It will be how much code you can reason about.
How are you seeing this? Does your team have language to name it, or is it still treated as “the system is complex, and that’s that”?