Recall your workday yesterday. You reviewed a PR. You traced a bug. You weighed two designs. All of it felt like thinking.
Now count something specific: how many things did you decide for the first time — decisions nobody in your organization had ever made before, that you made and now own?
For most of us, on most days, the honest answer is zero. And yet the day felt full of thought.
This article takes that discrepancy seriously and follows it all the way down. The destination is a strange one: thinking is required far more rarely than it feels — and that scarcity is not a defect. It is the reason your brain doesn't crash. Along the way, it explains why your AI agent's long reasoning traces are a bug report about your organization, not a feature of the model.
This is a chain argument. Each section leans on the previous one. Sampled in the middle, it will read as assertion; walked from the start, it is a derivation.
1. Inference stays inside the premises. Thinking doesn't.
Two words, two operations.
Inference derives conclusions from given premises. It is closed under the premise set. It is computation, and given complete premises, it is mechanizable. A reasoning model's "thinking" is literally this — more tokens buy a deeper walk through the same premise space, never an exit from it.
Thinking includes choosing and creating the premises themselves. Which question to pose, which axis to cut along, which trade-off to accept. Nothing outside the premises can be reached by inferring harder; what comes out instead is the most articulate rendering of the training distribution's centroid.
So the first fixed point: long inference is not a substitute for thinking. Thinking is the act of choosing the space in which inference runs — not the act of walking that space for a long time.
But "creating premises" is vague. Let's sharpen it in stages.
2. Thinking produces a proposal, not a decision
First refinement: thinking is the act of drafting a quality definition against a goal — and the draft is a proposal, something you put in front of stakeholders. It is not yet a decision.
Two things follow.
Thinking acquires a completion condition. A quality-definition proposal is something others can accept, reject, or amend: articulated, with axes and criteria. Vague rumination that hasn't reached that form isn't finished thinking. Whether you "thought" stops being a feeling and becomes a property of the artifact.
And thinking gets separated from deciding. Drafting the proposal is thinking; closing it into a decision happens through stakeholder coordination. Thinking is the hinge between two coordination acts — the goal handed to you, and the ratification you seek.
One more cut, because it matters later: generating candidates for a quality definition is something an LLM does rather well. So the irreducible core of thinking is not candidate generation. It is picking one candidate and putting it forward under your own name — "this proposal is worth your coordination time." A proposal binds the proposer. Hold onto that; it becomes the whole story.
3. Imagined stakeholders cannot say no
Whatever you propose gets tested. Against whom?
If the stakeholder is real, their response arrives from outside your model of the world: the No you couldn't generate, the objection you didn't anticipate. That resistance can falsify your framing. Revising against it is how a framework earns its shape.
If the stakeholder is imagined, their "response" is generated by your model of them. Adjusting your proposal to satisfy it means fitting your model to your model. Information is processed — implicit premises get combined and exposed — but no external information enters the loop. Nothing arrives that could refute you. There is a plain word for this: self-satisfaction.
The deep difference is failure. An imagined stakeholder cannot fail you — ask, and a plausible response always comes back. Agreement from a system that cannot refuse is not agreement.
Generalize it: what matters is not self versus other, but whether the verification circuit can reject you. Running the code, running the experiment, finishing the proof — all solitary, all capable of failure. Reality is a stakeholder that cannot be persuaded. Thinking completes only when its product passes through a rejectable circuit: reality, logic, or an actual other. A thought that closes on itself influences no one; influence is the downstream effect of having survived a circuit that could have said no.
(Notice what this says about "have the LLM role-play a skeptical customer." The model's resistance is resistance from the distributional centroid — not that stakeholder, on that issue, on that day. It is self-satisfaction, industrialized. Simulation is legitimate exactly as long as it prepares for contact with the rejectable circuit; the moment it replaces contact, it's the loop that never leaves your head.)
4. Why software feels thought-dense: contamination
Now bring this to our field. Software quality is built in through process, and the process seems to demand thinking everywhere. It surfaces in the PR.
But not every item requires thought. A few do, and because they're mixed in unlabeled, the whole bundle demands the posture of thinking.
Look at a PR as a bundle. Of a hundred diffs, ninety-five are pure inference — a rename's propagation, a standard pattern applied. Three or four apply judgments that already exist somewhere and should resolve by reference. One or two are genuine judgment: a quality definition that doesn't exist yet, requiring a proposal. And these three kinds arrive indistinguishable in form.
So the reviewer must pay judgment-grade attention to everything. Attention cost runs at O(all items), not O(judgment items). Software development isn't thought-dense; the location of thought is unknown, so the posture of thought is forced everywhere. What you're paying isn't the cost of thinking. It's the cost of searching for the judgments.
5. Judgments are a vein, not a spring
Here's the dynamic part: a given judgment doesn't surface in PRs forever. Once it surfaces, you set the quality standard and handle it. From then on, that class of case demotes to inference — apply the standard.
Judgments are not a spring that flows forever. They are a vein that depletes with each exposure. The healthy loop: contamination → first exposure → standard ratified → distributed → resolved by reference thereafter. Each cycle, the unlabeled area shrinks.
Which gives a mid-point answer to the opening question. The amount of thinking a domain demands is not a property of the domain. It is the difference between its novelty inflow rate and its judgment capture rate. The same job demands ever less thinking if capture works — and re-stages the same judgment as "thinking," forever, if it doesn't. You can observe capture failure directly: the same review comment, recurring across PRs and authors. The correction is delivered every time; it is never ratified, never distributed; it lives in one reviewer's head and evaporates when they leave.
6. Manufacturing solved this a century ago — in a different category
If "once it surfaces, standardize it" sounds familiar, it should. Statistical quality control industrialized exactly this loop: root-cause analysis terminating in a revised standard, control charts separating common-cause from special-cause variation, horizontal deployment, poka-yoke fixtures that make deviation physically impossible. "Quality is built in through the process" is their slogan.
Software engineering tried to import all of this in the 1990s and got a degraded copy. The interesting question is why — and the answer is not just that our standards lived in wikis nobody read. The category was wrong.
| Industrial product | Software | |
|---|---|---|
| What the standard governs | Same input, same output | Different inputs, different outputs |
| How the standard is written | Pre-enumerates every instance | Can only be written at the level of a type |
| How it's applied | Matching — is this unit inside tolerance? | Subsumption — does this one-off case fall under that rule? |
| Cost per application | ~zero (measure it) | An act of inference, every time |
| Enforcement medium | Jigs and fixtures — physics | — none existed |
Matching requires no inference, which is why it could be embedded in a jig. Subsumption — recognizing that an unprecedented case falls under a written rule — requires reading, analogy, judgment about applicability. That is what could never be mechanized. Standards evaporated in wikis because their enforcement required human reading, and human reading cannot be compelled.
Which answers "why now" more precisely than "models got smart." Subsumption machines existed before — type checkers, rule engines, expert systems — but each operates only inside a formal system fixed in advance: the standard must first be reduced to rules, and everything that resisted reduction was left out. An LLM is the first general-purpose subsumption machine that operates over natural-language standards. It can apply a written judgment standard, as written, to a case it has never seen. Software can finally build its jigs — not because agents obey, but because the operation a jig needs here is subsumption over standards that cannot be reduced to fixed rules, and no prior mechanism could perform it without formalizing the standard away.
7. Most of design is not thinking. It is sorting.
Descend one more level, to what software actually is: the maintenance of consistency in an information structure. Requirements, design, code, tests, operational constraints — a web of mutual references that must close without contradiction. No element is correct in isolation; correctness lives in the graph. That's why rationale is mandatory: a rationale is an edge in the consistency graph, and a design element without one is a dangling node that makes consistency unverifiable.
Now treat the organization's existing information — its facts, priorities, ratified judgments — as an axiom set. Then most of what we call design work has a precise, deflating name:
Sorting: computing a consistent arrangement over the axiom set, without changing it. A requirement changes; propagate the impact; rearrange until nothing contradicts. Constraint satisfaction. It adds no new commitment to the system. It is not thinking.
Thinking is demanded only where the computation fails, and it fails in exactly two ways:
- Underdetermination. The axioms don't pin down this design point; several consistent arrangements exist. Choosing one means adding an axiom — drafting a quality definition and getting it ratified.
- Overdetermination. Axioms collide; no consistent arrangement exists. Relaxing one means changing a ratified decision — pure stakeholder coordination.
The test compresses to one line: does this act change the set of decisions, or only their arrangement? Arrangement is sorting. Decisions are thinking.
And note the discovery property: you can't know in advance where the axioms run out. You find the holes and collisions only by running the sort. Sorting is simultaneously the work that needs no thought and the only procedure that locates where thought is needed. That's why design feels thoughtful from the inside — mid-search, you can't tell whether the next step is mechanical propagation or an undecided hole.
8. Then less reasoning is better
If the work is sorting, a counterintuitive spec follows. Reasoning volume should be minimized. Detect contradictions and trade-offs; report them; stop. That's the whole job.
Why is more reasoning worse? Because surplus reasoning fills. The sort needs exactly two kinds of inference: subsumption and impact propagation. Anything beyond that is the model deriving its way across a hole where an axiom is missing — silently generating a plausible substitute axiom and continuing. A long reasoning chain is where unratified axioms get injected, and deeper reasoning makes the injection more articulate and harder to detect. In the sorting regime, reasoning power is the power to pave over holes — and what you want is the power to stop at them. Same axis, opposite directions.
Precision matters here: the thing to ban is not depth. Deduction closed under the axiom set may run as deep as it likes — contradictions sometimes surface only at the end of a long propagation chain, the way a linker finds a symbol collision deep in the dependency graph. The ban is on importing hypotheses from outside the axiom set. The spec is not "shallow inference" but conservative inference: closed under the given axioms, halting where closure is impossible. Undefined reference → stop. Duplicate, conflicting definitions → stop, and return the minimal conflicting set.
This also makes reasoning tokens a diagnostic. On a stable task mix, thinking-token volume is a proxy for axiom deficiency. If it declines as you distribute judgments, distribution is working. If it doesn't, the model is guessing something, every time. Frontier reasoning-tier pricing, in this regime, is the fee for making a model guess what a one-page decision record should have said.
9. Three regimes, one misallocation
Why, then, is the entire industry racing toward maximum reasoning? Because AI researchers explore new frameworks for a living. For them, scaling reasoning is legitimately valuable. Most other fields are not like that.
Cognitive work splits by the state of the axiom set:
| Regime | Axioms | Closed by | Does reasoning scale? |
|---|---|---|---|
| 1. Sorting | Closed | — (just compute) | Harmful — it fills holes |
| 2. Research | Open | Nature — experiments and proofs reject | Yes, legitimately |
| 3. Coordination | Open | Agreement | Can't reach it, in principle |
In research, the axiom set is the deliverable; abduction — mass hypothesis generation — is the core of the job, and nature does the rejecting. Benchmark culture (olympiad math, competitive programming, frontier-science evals) is an exam shaped like the model-makers' own work. Models are optimized by the one professional community for whom reasoning scaling truly pays, toward that community's epistemic situation — then sold, on the same axis, to everyone else.
But organizational work lives overwhelmingly in regimes 1 and 3. In regime 1, surplus reasoning manufactures defects. In regime 3 — priorities, acceptable trade-offs, quality definitions — no amount of reasoning derives the answer, because the missing axiom is not discovered. It is decided. It has no truth value. It has only commitment.
(Even the "research-like" moments inside a company — architecture selection, tech evaluation — are mostly regime 3 wearing regime 2's clothes. Enumerating candidates and mapping the trade-off structure collapses into sorting. The final pick is not made by nature. It's made by stakeholders.)
10. What people actually want from AI
Read the demand side through this lens and it splits into three layers — all miswired.
The stated demand is "think for me" — regime 2 shaped. It comes from the contamination illusion: people who experience their work as thought-dense try to delegate "thinking," receive the centroid's articulate guess, feel the something's off residue, and conclude the models aren't ready. This disappointment will be reproduced by every model generation, because the expectation's shape comes from a misdiagnosis of the work.
The satisfiable demand is sorting — closure computation, impact propagation, contradiction and trade-off detection. Unglamorous, and absent from the demand vocabulary, because sorting is subjectively indistinguishable from thinking. The customers cannot name their own need. That's the demand-side explanation for a missing product category: the conservative sorting engine — large context, cheap tokens, and a discipline of stopping.
The hidden demand is "decide for me." Coordination hurts. Standing between stakeholders, staking your name, absorbing the No — it's the most draining part of work, so it's the part people most want to shed. This demand is unsatisfiable in principle: an axiom closed by agreement has no truth value, and a model cannot stake a name. But it is simulable — the model will always return a plausible "you should do X," and it is a system that cannot fail you. Accept that output and something has been decided with no one having decided it. An unratified centroid axiom enters the organization's decision set wearing a decision's face, and when it turns out wrong, there is no one to trace it back to.
There is only one correct wiring. Make sorting the product — sort, don't fill, stop. Toward deciding, be peripheral, never substitute: surface the undecided as undecided, return the minimal conflicting set, keep what was decided from evaporating. The right job for AI is not to make deciding easier. It is to make not-having-decided impossible to hide.
11. Terminal: sorting and signature
One honest observation about the argument you just read. Every refinement of "thinking" carved off a part that turned out to be sorting. Candidate generation was absorbed into inference. Even the drafting of a proposal is, on inspection, computation over an implicit axiom set — your experience, the organization's scar tissue, your read of the power map: axioms that exist but were never written down. Take the limit and a suspicion appears: maybe every operation deserving the name cognition is sorting.
What survives the reduction is exactly one thing, and it is not a cognitive operation. The signature. "We go with this one," under your name. And here is the precise statement — the sloppy version says the signature "creates no information," and the sloppy version is wrong, because everyone's predictions and behavior change downstream of it. Precisely: a signature derives no proposition's truth value. It establishes one option as an axiom that all subsequent inference will reference. Nothing happens on the descriptive plane; the normative plane changes. It's not that signing can't be mechanized — it isn't computation, so mechanization doesn't apply as a predicate.
The system closes into a loop: sorting exposes an underdetermined hole → thinking drafts a proposal → coordination selects → the signature establishes the axiom → the next sort runs on top of it. The signature isn't a mystical residue outside cognition. It's the state transition that connects one sort to the next. (Which yields a practical corollary: establishing an axiom means making it referenceable — an identity, a place it can be resolved from. A decision made in someone's head, or ratified verbally and filed nowhere, changed the normative plane without changing the reference structure. Downstream sorting keeps running on the old axioms. That is the entire mechanism of "we decided this, why is nothing different.")
But don't overrun the reduction — an earlier draft of this article did, claiming thinking "doesn't exist as a category." Too strong. The accurate claim: thinking exists. It is rarely required. And its rarity is normal — in fact, it is the design condition.
If every act demanded axiom generation, cognition would not function. A system that re-examines all premises before every step never takes a step — AI research hit this wall decades ago and named it the frame problem. Your brain doesn't crash not because it can think at volume, but because it runs an amortization machine that keeps the demand for thinking scarce. Decide once; demote to habit; run it as procedure thereafter. A habit is judgment distribution inside one person. Organizational onboarding is the same amortization at a different scale. The capture loop of section 5 isn't an organizational invention — it's the externalization of how cognition was viable in the first place.
So the pathology was never that we think too little. It is mismatch between demand and supply: filling a hole that demanded thinking with a plausible centroid (humans do this too — it's the human-side silent convergence), and forcing the posture of thinking onto territory that only needed sorting (that was contamination). Health is when the scarce demand for thought is met exactly where it occurs — and nowhere else. An agent that "thinks" constantly is a cognition that refuses amortization: the design your brain discarded, brute-forced with compute.
Predictions
Four ways to break this:
- Reasoning-token decay tracks judgment distribution. On a stable task mix, teams that distribute ratified judgments will see agent thinking-token volume fall; teams that don't, won't — across model upgrades. If token volume falls to near-floor without any judgment curation, this theory is wrong.
- Recurring review comments measure capture failure. Where a capture loop is installed (surface → ratify → distribute → reference), the distribution of review comments shifts over time from "we don't do it that way here" toward pure derivation errors. No shift, no theory.
- Human fatigue concentrates at signature points. As sorting is delegated, practitioner exhaustion doesn't vanish — it localizes at the moments of proposal and ratification. If fatigue stays uniformly distributed across the workday after real judgment distribution, this theory is wrong.
- A "conservative sorting engine" category emerges — large-context, cheap, halt-disciplined — and wins regime-1 workloads against frontier reasoning tiers. If regime-1 buyers keep paying reasoning-tier prices at equilibrium, this theory is wrong.
Monday morning
Take this week's review comments on your team and put each into one of three bins: (a) derivation error — the logic was wrong; (b) "we don't do it that way here" — a judgment existed and wasn't distributed; (c) nobody ever decided this. Bin (a) is inference failing, and models will keep shrinking it for free. Bin (b) is your evaporation rate. Bin (c) is your organization's real backlog. Now pick one item from (b), write the judgment down with a stable ID, require your agent to cite it when it applies — and to stop, as an error, when it hits a (c).
Then watch what happens to the length of your agent's reasoning traces. If this article is right, you've been reading those long traces as diligence. They were the length of everything your organization never decided.
Top comments (0)