Code Moves Faster Than Understanding

Burn More Tokens, Keep the Thinking

I told my team to use AI more.

In plainer words: burn more tokens. If you are not using AI enough, you are losing leverage.

But as adoption increased, I started seeing a different failure mode.

Some engineers were burning more tokens on tasks, but not yet moving faster. More importantly, they were not always building better judgment. They would feed task requirements into AI, accept a plausible task completion, and move on.

The code might work. The branch might pass review.

But when I asked why the design was shaped that way, or how the change fit into the larger system, the answer became rambling.

That worried me more than a messy implementation.

Messy code is visible. You can refactor it. You can add tests. You can point at the awkward dependency and say, “This needs to change.”

Lost understanding is lost control.

I read a paper that gave better language to this problem: cognitive debt and intent debt. The part that stayed with me was an example of a team that shipped quickly, then stalled because no one could explain why decisions had been made or how different parts of the system were supposed to work together.

AI does not only change how fast we produce code. It changes where learning happens.

When you write code yourself, even badly, the friction forces some understanding into your head. You make small decisions. You hit errors. You notice boundaries. You build a rough theory of the system.

When AI fills in the path too quickly, that friction can disappear.

Engineers may still feel productive because they are prompting, reviewing, and merging. But the reasoning that would have built intuition has been bypassed.

This is cognitive surrender: accepting AI output with minimal scrutiny, while still feeling like you were in control.

So I made one small change to my AI review bot.

For each review, it now indicates how much human attention the change still deserves after AI has done the first pass.

This is a small mechanism, but it points to a larger shift.

As agentic engineering grows, code review will not scale by asking humans to inspect every line with equal intensity. But it also cannot scale by letting humans become rubber stamps for generated code.

The question is no longer only: did AI help us ship this?

It is also: did we preserve enough understanding to safely change it later?

Burn more tokens, yes.

But do not burn the thinking that makes those tokens useful.

---

TL;DR of the paper From Technical Debt to Cognitive and Intent Debt Rethinking Software Health in the Age of AI:

A software system has three layers that must stay aligned. Intent covers goals, constraints, and objectives held by stakeholders and encoded in artifacts such as specifications and tests. Code covers implementation, architecture, dependencies, and infrastructure. Shared understanding covers the team's mental models of how the system behaves and how it can be changed.

Cognitive offloading delegates a bounded task to a tool; surrender bypasses the reasoning that would have built intuition, criticism, and system understanding. Because surrender can also inflate confidence, teams may not notice the debt until changes produce surprising behavior.

Intent debt differs from the broader phrase context debt. Context debt is the missing information an AI agent needs to work effectively; intent debt is the missing or degraded purpose, constraints, and rationale that should guide both agents and humans.