Here's the thread running through everything today: AI systems are now building software, optimizing codebases, and designing their own training runs. The loop is closing faster than almost anyone predicted. And that's reshaping not just what AI can do—but what developers are for.

The Infrastructure Layer Is Now the Moat

Multiple researchers converged on a single observation this week. Model quality alone is no longer the bottleneck. What matters now is the harness—the scaffolding of tools, memory, retrieval, and runtime that surrounds the model.

Simon Eskildsen of Turbopuffer put it sharply in a conversation this week. The old retrieval-augmented generation—or RAG—pattern was simple: one search call at the start of an LLM query, grab some context, fill the window. That pattern is dead. Agents now fire dozens of parallel search queries mid-task, turning retrieval infrastructure into a high-concurrency tool call layer. Eskildsen said Turbopuffer is cutting query pricing five times to accommodate this. The economics of search are inverting.

This connects to what the broader AI infrastructure community is calling the "harness problem." The MCP—Model Context Protocol—debate illustrates it well. Despite jokes that MCP is dead, Uber is reportedly using it internally as the connective tissue between AI agents and enterprise services. The real issue isn't the protocol. It's that building reliable harnesses around that protocol—with memory, observability, and proper sandboxing—remains genuinely hard.

Eskildsen made a deeper point worth sitting with. Models can learn to reason. But they cannot compress the world's knowledge into a few terabytes of weights. They need external systems holding truth in full fidelity. That's what search infrastructure is becoming—not a feature, but the epistemic anchor for agents operating at scale.

On the retrieval front, there's a crystallizing debate between single-vector and multi-vector approaches. Google's new Gemini Embedding model maps text, images, audio, and video into one vector space. But researchers at Mixedbread are arguing—loudly—that late-interaction architectures, sometimes called ColBERT-style—which score documents using multiple vectors rather than one—immediately outperform single-vector baselines at scale. One researcher called it "borderline irrational" to keep betting on single-vector embeddings if you can make the infrastructure work.

The Recursive Loop Is Opening

Ethan Mollick published what may be his most important piece in years. His argument: we can now see the shape of the thing.

The METR Long Tasks benchmark—which measures how much autonomous work an AI can complete reliably—has been climbing steeply. Models are now scoring ninety-four percent on the Google-Proof Q&A benchmark, a test where graduate students using Google only hit thirty-four percent outside their specialty. On GDPval, where industry experts judge AI against experienced human performance on complex tasks, the latest models match or exceed top humans eighty-two percent of the time.

But the more striking development is structural. A three-person team at StrongDM, a security software company, has built what they call a Software Factory. Two rules govern it: code must not be written by humans, and code must not be reviewed by humans. Each engineer spends the equivalent of their salary—around a thousand dollars a day—on AI tokens. Coding agents build from product roadmaps. Testing agents simulate customer environments and provide feedback. Humans review finished products without ever seeing the underlying code.

This isn't science fiction. It's in production now.

Meanwhile, Anthropic's Claude reportedly writes between seventy and ninety percent of the code for future versions of itself. OpenAI stated that its latest Codex model was—quote—"instrumental in creating itself." Dario Amodei said at Davos that Anthropic engineers barely write code anymore. Demis Hassabis confirmed that closing the self-improvement loop is an explicit goal at every major lab.

Recursive self-improvement—the idea that AI systems accelerate their own development—has been theoretical for decades. It is now on the product roadmap.

Tobi Lütke, Shopify's CEO, gave this a vivid illustration this week. He opened a pull request against Liquid—Shopify's open-source Ruby templating engine—with ninety-three commits from around a hundred and twenty automated experiments. The result: a fifty-three percent faster parse-and-render, sixty-one percent fewer memory allocations. On a codebase that hundreds of contributors have optimized for twenty years.

His method was an adaptation of Andrej Karpathy's "autoresearch" pattern—where an agent brainstorms potential improvements, then runs them as experiments one at a time, guided by a benchmarking script. Simon Willison called out the key unlock: a robust test suite with nine hundred and seventy-four unit tests made the whole thing possible. Without reliable tests, "make it faster" is not an actionable goal. With them, it is.

Willison also noted the human angle. Coding agents are enabling people in high-interruption roles—CEOs, executives, researchers—to write meaningful code again. Lütke's GitHub contribution graph shows a sharp uptick in November 2025, exactly when coding agents crossed a capability threshold.

The Developer Identity Split

All of this is forcing a question that the industry has been circling for months. What is programming for?

A New York Times Magazine piece this week—drawing on more than seventy developer interviews—captured the emerging divide. Les Orchard articulated it cleanly: AI-assisted coding is exposing a split that was always there but invisible. The craft-lovers and the make-it-go people sat next to each other for years, writing code by hand, using the same tools. Now there's a fork. You can let the machine write the code and direct what gets built—or insist on hand-crafting it. The two camps are making different choices, and their motivations are suddenly visible.

Willison added a pointed observation about testing as the unique advantage developers have over other knowledge workers. Lawyers can't automatically verify an AI-generated brief for hallucinations. Developers can. "If you're a lawyer, you're screwed," he said. "Programmers have it easy." Testability is the tether to reality.

From the practitioner side, Claude Code users are discovering nuance. Four months of building a two-hundred-twenty-thousand line iOS app with AI revealed that the hard parts aren't the coding. They're design decisions, debugging with real users, and security. One developer noted that CSS precision—making two buttons exactly the same height—still trips up the model. Another found that Stop Hooks and persistent Memory Files—features that automate follow-up actions and maintain project context across sessions—completely changed how reliable Claude Code becomes for complex multi-step work.

The signal from all of this is consistent. The model is increasingly a component, not the product. What matters is what wraps it: the tests, the memory, the tooling, the harnesses. And whether the person directing it is asking ambitious enough questions.

Swyx put it well in a brief editorial note: the people who pushed LLMs past their apparent limits—the ones just on the right side of insane—benefited. The pragmatic managers who accepted models as they were mostly didn't go anywhere. Raising your aspirations for what these systems can do remains, perhaps, the highest-return activity in AI right now.