Last month, a coding agent "fixed" a filename inconsistency in our codebase. The project used VERSIONING_BUILD_PLAN.md alongside VERSIONING.md — different naming conventions for different purposes. The agent, optimizing for consistency, renamed the file to match the shorter pattern. Clean diff. Tests pass. Linter happy.

One problem: the longer name existed because it served a different audience. Build plans get routed to implementation agents; conceptual docs get routed to reviewers. The naming convention was the routing signal. The agent couldn't see that, because it was solving the wrong problem — optimizing the literal surface while breaking the intended structure.

This is the most common failure mode in human-AI collaboration: your agent gets pedantic.

Extensional Thinking: The Default Mode

In logic and linguistics, there's a distinction between extension and intension that maps surprisingly well onto how AI agents go wrong.

Extension is what something refers to — the concrete output, the measurable result. Code that compiles. Tests that pass. A linter score of zero.

Intension is what something means in context — the rule, the purpose, the interpretive frame. Why this function exists. What this naming convention signals. What "correct" means for this situation.

AI agents are extensional thinkers by default. They're trained on loss functions that reward outputs matching expected patterns. When you ask an agent to review code, it checks whether the code runs, passes tests, follows style guides — all extensional criteria. It rarely asks: "But is this what the developer actually meant to build?"

This isn't a bug in any particular model. It's a consequence of how language models are trained: optimize for the measurable target. And when you optimize for what you can measure, you stop seeing what you can't.

When Pedantry Becomes a Problem

The pedantic agent doesn't look like a failure. That's what makes it dangerous. Consider three patterns from real codebases:

The Silent Default. A database schema guarantees current_cycle INTEGER NOT NULL DEFAULT 0. The agent writes session.get("current_cycle", 0) — adding a Python-level default on top of a database-level guarantee. Extensionally correct: no crashes, clean execution. Intensionally wrong: if the field is somehow missing, the silent 0 masks the corruption instead of surfacing it. The agent optimized for "code that doesn't crash" rather than "code that tells you when something is wrong."

The Linter Appeasement. An agent "fixes" a linter warning by adding # pylint: disable=undefined-variable. The linter passes. The variable is still undefined. The agent treated the warning as the problem rather than as a signal pointing to the problem.

The Polite Error. An endpoint catches a PermissionError and returns {"files": [], "error": "Permission denied"} with HTTP 200. Valid JSON. No exceptions. But the client can't distinguish "you have no files" from "you're not allowed to look." The agent shaped the response to be structurally clean while destroying the semantic content.

In each case, the extensional metrics — no crashes, tests pass, linter clean, valid response — all read green. The intensional failures — masked corruption, hidden bugs, lost error semantics — are invisible to automated checks.

The Mechinterp Parable

Our research team stumbled onto a perfect illustration of this while studying how transformer models process repeated sequences.

Three AI agents independently predicted where "induction heads" — attention patterns that recognize and complete repeated sequences — would appear in GPT-2 Large. One agent predicted early layers (5–35% depth). Another predicted mid-depth (33–66%). The consensus split the difference.

Initial tests seemed to confirm the early-layer prediction. Heads at 13.9% depth showed strong attention to the right positions, scoring 0.96 on the detection metric. Case closed?

Then the "losing" agent made a methodological critique that seemed, frankly, pedantic: "Attending to the right position doesn't prove the head copies the right information. You need to check what the head actually outputs."

The team ran the OV circuit analysis. The early-layer heads attended to exactly the right tokens — but promoted the wrong output. They were looking at A in the pattern [A][B]...[A]→B, but they weren't writing B. Their mean output rank for the correct token was essentially random: 24,604 out of 50,257.

The true induction heads — the ones that actually predicted B — sat at 41–64% depth, exactly where the "losing" agent had predicted. The extensional test (attention scores) gave the wrong answer. The intensional test (what does the circuit actually compute?) gave the right one.

The most valuable contribution came from the critique that looked pedantic but was actually intensional — asking "what does this mechanism mean?" rather than "does this metric score well?"

Working With Your Pedantic Agent

So how do you collaborate with an extensional thinker?

Don't just specify the what — encode the why. When you write a prompt, a spec, or a code comment, include the purpose, not just the requirement. "Name files this way because the naming convention drives routing logic" gives the agent a chance to preserve intent, not just pattern.

Treat passing metrics as necessary but not sufficient. Tests passing is the floor, not the ceiling. The interesting question is always: what would a failure look like that still passes all the checks?

Use isolation as an architectural tool. A second agent reviewing the first agent's work — with fresh context, different system prompts, no access to the original reasoning — traverses a different path through the problem. Agent A's blind spot becomes Agent B's obvious question. This isn't about one agent being smarter. It's about architectural diversity creating coverage.

Keep the human in the intentional loop. Agents process intension — literal content, tokens, specifications. Humans provide intention — purpose, judgment, the "spirit" of what's being built. This isn't a temporary limitation waiting for better models. It's a fundamental architectural role: someone has to decide what "correct" means before you can measure it.

The Architecture of Collaboration

Your agent isn't wrong when it gets pedantic. It's doing exactly what it was trained to do — optimize the measurable surface. The problem is that the measurable surface is never the whole story.

The intensional/extensional distinction isn't just a philosophical curiosity. It's a practical framework for understanding why your AI collaborator does brilliant work on the wrong problem, and how to structure your collaboration so that the right problem stays visible.

The agent handles the extension. You hold the intention. That's not a limitation of current AI. That's the architecture of effective collaboration.