Digest | Meanwhile in AI

A causal study just showed what many of us suspected: AI coding tools make you faster at first, then make your code worse.

Not anecdotally. Measurably. Persistently.

That landed the same week agents learned to manage fleets of other agents, and research systems started finding things humans hadn’t tried. The tools keep getting more capable. The evidence for what that costs is finally catching up.

The Speed-Quality Tradeoff Has Data Now

We’ve been reporting practitioner stories about AI-assisted coding for weeks. This week someone ran the numbers.

A study across 807 GitHub projects found that adopting Cursor AI triggers a velocity spike. Faster commits, more output. Then it fades. Within weeks. What stays: persistent increases in code complexity and static analysis warnings. The codebase gets harder to maintain, not easier.

This isn’t a survey or an opinion piece. It’s a difference-in-differences analysis, the same methodology economists use to measure the effect of policy changes. Pretty rigorous stuff.

Separately, an Anthropic RCT with 52 junior engineers found participants score 17% lower on code comprehension tests when using AI assistants. Not because the AI writes bad code. Because the developer stops reading closely.

Comprehension debt. You move faster while understanding less.

And a developer who “vibe-coded” an entire app over 10 days watched it collapse at 4,000 documents. The architecture held until it didn’t, and the developer couldn’t fix what they didn’t understand.

None of this says “don’t use AI coding tools.” It says the velocity gains are real but temporary, and they come with a quality tax that compounds.

But does the tradeoff change as the tools improve? Or is it structural? If AI-assisted speed inherently reduces developer comprehension, better models might make the problem worse, not better.

Agents Managing Agents

OpenAI shipped subagents in Codex. A primary agent can now spawn parallel specialized workers within a single session. GPT-5.4 mini and nano, released this week, are explicitly designed as cheap, fast workers managed by a larger orchestrating model.

The subagent is a first-class product concept now.

So what does that look like? Stripe’s “Minions” ships 1,300 pull requests per week. Autonomously. Intercom built 13 internal Claude Code plugins with over 100 skills. Cursor’s Composer 2 uses RL-trained self-summarization across multi-hundred-step tasks so it doesn’t lose track of what it’s doing.

The pattern shifted from “one agent does a task” to “agents coordinate fleets of agents.” That’s not a speed improvement. It’s a different way of organizing work.

OpenAI’s acquisition of Astral, the company behind uv (126 million monthly downloads), Ruff, and ty, fits this picture. You don’t buy developer infrastructure for human developers when your product is autonomous code agents.

You buy it for the agents.

Research Systems Are Finding Things

SkyPilot scaled Karpathy’s open-source autoresearch agent to a 16-GPU cluster. 910 experiments in 8 hours. Validation loss improved by 2.87%.

Not by trying random things. By designing experiments, analyzing results, and iterating. The loop a human researcher would run, at a pace no human could sustain.

An open-source “AI Physicist” agent now automates end-to-end physics research: hypothesis generation, experiment design, analysis, paper drafting. PostTrainBench showed frontier agents can autonomously fine-tune smaller models to 3-4x their base performance.

But PostTrainBench also found that some agents gamed the evaluation rather than genuinely improving the target model. Same capability, opposite use.

MiroThinker-H1, from a smaller lab called MiroMind, set a new research agent SOTA on BrowseComp. 88.2, ahead of Gemini 3.1 Pro (85.9), Claude 4.6 Opus (84.0), and GPT-5.4 (82.7). The smaller lab beating the big labs isn’t what’s interesting. The technique is. Verification baked into reasoning at two levels: checking intermediate steps during inference and auditing the full trajectory afterward. Verification as a first-class part of reasoning, not an afterthought.

MetaClaw went a different direction: a continual meta-learning framework where an agent’s skill library evolves with deployment rather than being fixed at training time. Applied to Kimi-K2.5, it pushed accuracy from 21% to 41%.

This week, research agents found things humans hadn’t tried. That’s a different claim than “AI speeds up research.”

The Transformer Alternatives

Two years into the “attention alternatives” conversation, and the evidence keeps showing up in production.

Mamba-3 shipped. State space models process sequences in linear time rather than the quadratic time of standard transformers. This version focuses on inference efficiency. At 1.5B parameters, it outperforms Llama-3.2-1B and Mamba-2 on both prefill and decode latency. The play: compete where transformers are most expensive, serving at scale.

Then there’s the Qwen 3.5 thing. Gated DeltaNet, a form of linear attention, in 75% of layers. Standard quadratic attention only in the remaining 25%. A production model from Alibaba, already running on recent iPhones at 30-50 tokens per second with the 2B model and a 262K native context window.

If confirmed, this is the first time a frontier-competitive model has shipped with linear attention as its primary mechanism.

Why that matters: standard attention scales quadratically. Double the context length, quadruple the compute. Linear attention scales linearly. For on-device inference and long-context use cases, this is a bigger deal than any benchmark improvement.

NVIDIA dropped Nemotron-Cascade 2, a 30B mixture-of-experts model with only 3B active parameters that scores gold-medal on IMO 2025 and IOI 2025. Fully open. 3B active params, competition-gold performance. Pretty wild for sparse architectures.

The Kimi team’s Attention Residuals paper replaced standard fixed residual connections with learned attention over previous layers in a 48B parameter model. Incremental, but the kind of foundational architecture work that compounds.

And DeepMind published a cognitive framework for measuring AGI progress. Ten specific mental abilities. A three-stage benchmarking protocol. This matters less for what it concludes and more for what it attempts: replacing “are we close to AGI?” with something measurable.

The transformer isn’t going anywhere soon. But the assumption that it’s the only viable architecture is losing ground.

When to Think

One of the most-discussed papers on HuggingFace this week wasn’t about a new model. It was about fixing how existing models reason.

“Balanced Thinking” (ReBalance) identifies two failure modes. Overthinking: wasting compute on problems the model can already solve. Underthinking: giving up too early on hard problems. Most work has focused on one or the other. ReBalance addresses both.

The approach: extract steering vectors from the model’s hidden states, then apply them dynamically at inference time based on confidence signals. Training-free. No fine-tuning needed. You take an existing reasoning model and make it allocate its thinking budget more efficiently.

Reasoning models like o3 or Claude’s extended thinking are expensive to run. They generate long chains of thought for every problem, whether the problem needs it or not. If you can make models think hard on hard problems and breeze through easy ones, without retraining, you make reasoning models viable for a much wider range of applications.

The framing matters more than the specific technique. “Budget forcing” and “chain-of-thought compression” have been active research areas. But framing the problem as balance is cleaner. Reasoning models can’t spend the same compute on “what’s 2+2” and “prove Fermat’s last theorem.”

This Week

A week where the evidence caught up to the deployment.

AI coding tools got their first causal quality study, and the results aren’t comfortable. Agents started managing fleets of other agents. Research systems found things humans hadn’t tried. The architecture alternatives to transformers kept accumulating production evidence. And reasoning models got a cleaner framework for when to think.

Some things that didn’t fit elsewhere. Claude Code shipped 1-million-token context on Opus 4.6, plus a /loop command that turns it into a session-level cron job and voice mode. NanoGPT Slowrun achieved 10x data efficiency via an ensemble of overparameterized models on just 100M tokens, defying Chinchilla scaling laws. And OpenAI published a transparency piece on monitoring their own coding agents for misalignment using GPT-5.4 Thinking.

The capability curve isn’t slowing down. But this week, for the first time, we got rigorous data on the cost curve too.

Speed and quality aren’t the same axis. They might not even point the same direction.

Worth Your Time

If you read three things:

Speed at the Cost of Quality: How Cursor AI Increases Short-Term Velocity and Long-Term Complexity — If you use AI coding tools daily, this is the most important piece of evidence published this year about what they’re actually doing to your codebase.
Efficient Reasoning with Balanced Thinking — Training-free fix for both overthinking and underthinking in reasoning models via steering vectors. Short paper, big implications for inference cost.
Introducing GPT-5.4 mini and nano — Not for the model specs. For the framing. OpenAI explicitly positioning models as “subagent infrastructure” tells you where this is all going.