Agents can do impressive work

AI agents have beaten games and executed complex code migrations, even full rewrites in new languages. But most real software work still requires human engineers to drive the process.

Tokenmaxxing didn't deliver

Engineering teams spent the first half of this year running armies of agents and adversarial loops. The results were disappointing: lots of dubious code, but no tsunami of incredible software.

We're in the trough of disillusionment

The hype cycle is playing out as it always does. We had utopian visions a few months ago that aren't working in practice yet. Now we need to figure out best practices and build missing primitives.

Engineers will focus on ideas

When software mostly drives itself, the most valuable engineering work will be having good ideas. Killer features and killer architecture still come from humans with domain expertise and problem intimacy.

“Killer features are still company-making.”

Setting up loops won't be the bottleneck

Right now, setting up viable agent loops is hard work. But that's because the toolchain isn't ready. Once we have the right pieces, loops will be easy to set up, easy to trust, and cost-effective.

Agents should catch bugs automatically

Most bugs have obvious intended semantics. Agents should detect and fix them without human judgment. A user logged in via SSO breaks a feature? An agent should catch and fix it.

Agents can handle production errors

When errors appear in production, agents should correlate them to recent commits, traffic changes, or infrastructure differences and patch them. Backends should basically never throw 500s anymore.

Design systems can self-enforce

Apps should use consistent fonts, colors, iconography, and spacing. Design systems should bootstrap and enforce themselves, with humans making confirmatory decisions.

Polish and UX details matter

Apps should behave as users expect. Ctrl-click opens links in new tabs. Disabled buttons explain why. Forms preserve data on refresh. Agents should handle these dozens of basic quality-of-life expectations.

Growth teams set goals, agents iterate

Agents should run growth playbooks: form conversion optimization, onboarding iteration, marketing pages. Growth teams focus on high-level ideas while agents test changes against real users.

Agents need to see the whole system

Bugs overwhelmingly come from areas where agents can't see them. If your app has third-party integrations agents can't exercise end-to-end, those integrations will have bugs.

“The bugs, overwhelmingly, come from the areas where agents can't see them.”

Global memory prevents repeated mistakes

Agents making boneheaded mistakes is fine. Agents making the same mistakes repeatedly is not. A global memory system needs to work across the entire toolchain so every agent learns from corrections.

Codebases need rot prevention

Something needs to prevent agents from leaving dead code, creating multiple ways to do the same thing, or misaligning the data model with the product. Otherwise codebases spiral into chaos.

Dev environments are the real bottleneck

The limiting factor for dev agents isn't the models themselves, it's the environments they operate in. Agents create bugs where they can't see: race conditions they can't reproduce, slow queries they don't understand.

“The agents are good enough to do a lot more of the work, if they're operating in good enough environments.”

Making dev environments agent-ready is hard

Creating cloud dev environments that let agents exercise code thoroughly is a bottomless pit of work with no way to quantify progress. It takes good ideas and focused engineering to fix these gaps.

Turn dev readiness into a science

Right now, making codebases agent-ready is an art. We need better ways to help teams know what low-hanging fruit exists, how to prioritize investments, and whether they're making progress.

Mine bugs to guide infrastructure work

Get good at finding bugs that matter. Fix them. Track the gaps that made validation hard. Use those traces to prioritize what makes a codebase more amenable to agents.

Benchmark agent readiness

Bootstrap a corpus of useful work for any codebase. Use that to determine high ROI ways to improve it for agents. Engineers can then focus on real high-value work: ideas and abstractions.

This mirrors the cloud transition

In the 2010s, moving to the cloud was messy at first. We had to figure out missing primitives. Now CI and CD setup takes an afternoon. The same transition will happen with agent loops.