The Brevity Revolution: How Forcing Your Coding Agent to Shut Up Makes It Smarter

Related articles

• The Agent Loop Just Became a Plugin
• Your Coding Agent is a Harness. The Model is the Commodity.
• Coding Agents Got Amnesia. Here Are the Tools Fixing It.
• Best Coding Agents 2026 Decision Guide

Here is a counterintuitive finding from a March 2026 research paper that should reshape how every developer configures their coding agent: when large language models produce shorter responses, their accuracy improves by 26 percentage points. Not on toy benchmarks. Not in cherry-picked edge cases. Across 31 models ranging from 0.5B to 405B parameters, on 1,485 problems spanning five real datasets.

The paper is Brevity Constraints Reverse Performance Hierarchies in Language Models, published on arXiv in early March 2026. Its central thesis is brutally simple: bigger models overthink, and overthinking introduces errors. When you force them to be brief, their accuracy climbs — and on certain problem types, it completely reverses the performance hierarchy. Small models that were winning suddenly lose. The large model’s superior latent capability, hidden under layers of verbal padding, gets unmasked.

Five months later, the coding agent ecosystem has taken this finding and built an entire product category on top of it.

The Numbers That Started a Movement

Let the data sit for a moment because the implications are staggering:

• 7.7% of benchmark problems exhibit “inverse scaling” — where models with 10–100× more parameters perform worse than smaller ones.
• On those problems, large models underperform by 28.4 percentage points under standard prompting.
• When you constrain large models to produce brief responses, accuracy improves by 26.3 percentage points.
• The performance gap shrinks by 67% — from 44.2pp to 14.8pp.
• On GSM8K (math) and MMLU-STEM (science), the hierarchy completely reverses. Large models go from losing by 13–27 points to winning by 8–16 points.
• Large models under brevity constraints produce 60% shorter outputs — the verbosity wasn’t adding value, it was subtracting accuracy.

The mechanism is straightforward: LLMs trained on human text learn that thorough, detailed responses are “good.” But in domains where a precise, compact answer exists — like code, math, or technical analysis — that learned thoroughness becomes overelaboration. Each extra sentence introduces a new opportunity for the model to contradict itself, drift off-topic, or hallucinate a wrong detail. Cutting the verbosity cuts the error surface.

This is not a minor academic curiosity. For coding agents — tools that produce thousands of tokens of output per session, where every unnecessary sentence is a potential misdirection — the brevity finding translates directly into fewer bugs, fewer wrong paths, and less money burned on tokens that don’t help.

From Paper to Product: The Tools Built on This Insight

By July 2026, the academic finding has become the fastest-growing subcategory in the coding agent ecosystem. Three major projects have crossed the 80,000-star threshold, each attacking the verbosity problem from a different angle:

Caveman: The Output Compressor (92K+ Stars)

Caveman is a skill for Claude Code, Codex, Gemini, and 30+ other agents that forces the model into terse, fragment-style communication. Install it once and your agent drops filler words, hedging phrases, and sycophantic preambles while keeping code blocks, commands, and error messages byte-for-byte exact.

The measured results: 65% average reduction in output tokens across 10 tested prompts, with reductions ranging from 22% to 87%. An “Explain React re-render bug” prompt drops from 1,180 tokens to 159. A “Set up PostgreSQL connection pool” prompt goes from 2,347 to 380.

But Caveman’s real innovation is its ecosystem. The original skill spawned four siblings:

The caveman-compress command rewrites your CLAUDE.md and other memory files into compressed format, cutting 46% of input tokens on every future session. That means not only is the agent talking less, it’s also reading less on startup — a double saving that compounds over time.

Caveman’s README links directly to the arXiv paper, and the author’s site calls it “Lithic Token Compression.” The self-awareness is part of the appeal: this is a developer who read the research, built the tool, and backed it with reproducible benchmarks. The benchmarks/ and evals/ directories in the repo let anyone verify the claims.

Ponytail: The Code Minimizer (87K+ Stars)

While Caveman compresses what the agent says, Ponytail compresses what the agent builds. It implements a six-rung “laziness ladder” that forces the agent to exhaust cheaper alternatives before writing new code:

1. YAGNI — Does this need to exist? If not, skip it.
2. Stdlib — Does the standard library do it? Use it.
3. Platform — Does the native platform feature cover it? Use it.
4. Dependency — Is there an installed dependency that works? Use it.
5. One line — Can this be one line? Write one line.
6. Minimum — Only then: write the minimum code that works.

The agent stops at the first rung that holds. The philosophy is the opposite of how most people configure their agents — instead of “be helpful and thorough,” it’s “be lazy and precise.”

Ponytail’s benchmark results on a real repository (FastAPI + React, 12 feature tasks, Claude Haiku 4.5, n=4):

The critical differentiator: Ponytail is the only approach that cuts every metric while maintaining 100% safety. The bare “write one-liners” prompt achieves similar speed and cost reductions but drops safety to 95% — meaning it occasionally skips validation, error handling, or security checks. Ponytail’s ladder explicitly exempts trust-boundary validation and data-loss handling from optimization.

ECC: The Cross-Harness Optimizer (231K+ Stars)

ECC — originally “Everything Claude Code” but now spanning seven harnesses — claims 40% fewer tokens per session through a different mechanism: optimized skills, memory persistence, and behavioral instincts that prevent agents from re-exploring known paths. Where Caveman compresses output and Ponytail minimizes code, ECC reduces waste by ensuring the agent doesn’t repeat work.

ECC’s Instincts v2 engine extracts patterns from successful sessions, scores them by success rate, and injects high-confidence rules into future sessions. The result: the agent starts with relevant context instead of re-discovering facts from scratch — a token savings that grows with usage.

Why This Is More Than Token Savings

The token economics matter, but they are not the main story. The main story is the accuracy finding.

The March 2026 paper demonstrated that verbosity doesn’t just waste money — it introduces errors. When a coding agent explains a refactoring approach in 200 words of prose before producing 10 lines of code, those 200 words are not neutral. They are opportunities for the model to state incorrect assumptions, make contradictory claims about the codebase, or drift toward an approach that conflicts with what it eventually writes.

This explains a pattern that experienced agent users have noticed but struggled to articulate: sessions where the agent produces verbose, detailed explanations of its plan, then executes something subtly different from what it described. The verbosity was not padding — it was the model reasoning in the open, exposing a chain of thought that was partially wrong before arriving at a partially right answer. Cut the verbosity and you cut the exposed reasoning errors.

The practical implication for developers is immediate. You can add a single skill to your agent — Caveman, Ponytail, or equivalent — and get not just cost savings but measurably better outputs. The research says this works because the fundamental constraint forces the model to allocate its limited “reasoning budget” to correctness rather than eloquence.

The New Skill Economy

What makes this trend structurally significant is the star count. Caveman at 92K, Ponytail at 87K, ECC at 231K — these are not niche tools. They represent a new layer of the coding agent stack that did not exist six months ago: optimization skills that sit between the raw model and the developer, controlling not what the agent can do but what it actually does.

This layer is converging on a principle that the best human engineers already know: the best code is the code you never wrote, and the best explanation is the one that doesn’t bury the answer.

The coding agent industry spent the first half of 2026 figuring out which model to use and which harness to run it in. The second half is about making whatever you chose produce better results — and the most effective lever, according to both the research and 180,000+ GitHub stars, is making it do less.

Your agent’s worst habit isn’t getting things wrong. It’s talking too much while doing it. The fix is already on GitHub. You just have to install it.