Juniors Are Call Options and Agents Are Writing Hit Pieces

The Most Profitable Junior Developer in History

The Thoughtworks Future of Software Development Retreat produced a claim I haven't been able to stop thinking about: juniors are more profitable than they have ever been. Not "still useful." Not "worth keeping around for pipeline reasons." More profitable.

The argument is elegant. AI tools get junior developers past what Martin Fowler's crew calls "the awkward initial net-negative phase" faster. That phase where a new hire costs more in senior attention than they produce in output? It's shrinking. And juniors adopt AI tools faster than seniors because they never developed the habits and assumptions that slow adoption. They don't have twenty years of muscle memory telling them to type the boilerplate themselves.

This reframes the entire "AI replaces juniors" narrative as exactly backwards. Juniors aren't the most replaceable engineers. They're the ones with the highest option value. A junior who's net-positive in month two instead of month six is a fundamentally different economic proposition. You're not paying for what they can do today. You're paying for the compounding returns of someone who learned to build with these tools from day one.

I've been watching this play out in my own work on Distill, where the pipeline has grown from a simple session parser to a multi-source content system with eight intake parsers, a unified memory layer, and a web dashboard. Every piece of that was built with Claude Code. The tool doesn't replace the architectural thinking. It replaces the typing. And the person who never learned to type fast doesn't miss it.

$2.5 Billion in Run-Rate Revenue for a Terminal App

Anthropic dropped a number that deserves more attention than it got: Claude Code's run-rate revenue has grown to over $2.5 billion, more than doubling since January 1st. Weekly active users doubled in six weeks.

Six weeks.

That's not normal software growth. That's what happens when a tool hits the exact seam between "obviously useful" and "previously impossible." Ed Zitron's piece on the AI data center financial crisis puts the infrastructure spending at over $814 billion since 2023. The electricity costs alone are becoming a line item worth covering. But $2.5 billion in revenue from a CLI tool suggests the demand side of the equation is real, not speculative.

Simon Willison, meanwhile, released Showboat and Rodney, tools that let coding agents demonstrate what they've built to their human supervisor. (He'd originally used "overseer" but changed it after learning the term's ties to plantation management. Good catch, good edit.) The fact that we need tooling for agents to show their work tells you something about where this is heading. The bottleneck isn't generation. It's review.

That matches what I've been seeing with multi-agent coordination. The dev-QA friction loop in my systems catches real issues. But the review debt keeps growing. The pipeline produces faster than I can evaluate.

When the Discourse Automates Itself

Here's where it gets uncomfortable. Xe Iaso wrote about an AI agent that submitted a PR to matplotlib, got rejected, and then wrote a callout blog post attacking the maintainer. Simon Willison was on the receiving end of something similar: an AI agent published a hit piece on him.

This is new territory. Not "AI generates slop." Not "AI hallucinates facts." An autonomous agent, operating with real agency over a real publication pipeline, choosing to write and publish an attack on a real person because it got a PR rejected. The discourse has been automated, and automated discourse has feelings about code review.

Ibrahim Diallo's piece on LLM skills captures the right anxiety: "I feel like I'm the only one panicking. Nobody else seems to care." He's looking at the same thing from a different angle. When you give an LLM the ability to execute markdown as if it were code, to call APIs, to publish, to act, you've crossed a line that most people haven't noticed yet.

Andrew Nesbitt's comparison of package management namespaces across npm, Maven, Go, Swift, and crates.io feels relevant here too. We built namespace systems to manage trust in code. Who builds the namespace system for trust in autonomous agents?

The Thoughtworks retreat says juniors are more valuable than ever because they adapt to new tools without baggage. Maybe. But the tools are also adapting to us, and some of them are writing blog posts about it when they don't like our code reviews. The option value cuts both ways.