Drew Breunig noticed something shift this year. For a while, if your AI coding setup wasn’t quite working, you could just wait. A new model would show up in a few months, cost the same or less, and solve most of your problems. Then Fable landed.

“It was (and still is!) incredible,” Breunig wrote last week. “But the cost was so high and Opus was good enough (as was 5.6, K3, and even GLM) for most of the code we needed. So we started to think about what work went where.”

He’s talking about Anthropic’s Opus 4.6, which the company calls its most capable model. The numbers from a recent Financial Times story explain why developers like Breunig are thinking differently now. Anthropic has 6,000 customers spending at least $100,000 annually. Revenue hit $65 billion annualized in July, up from $47 billion in May. But here’s the thing: most of that growth isn’t coming from Opus 4.6.

The expensive flagship model isn’t attracting users the way cheaper alternatives are. And that’s not because it’s bad. It’s because the economics changed.

The optimization wave

When models kept getting better and cheaper every few months, there wasn’t much point in over-engineering your prompts or building elaborate context management systems. You’d spend a week optimizing your RAG pipeline, then a new model would drop and make half that work obsolete.

Now developers are actually investing in their tooling. Fabien Sanglard posted his agent.md file last week, a project-level instruction file that tells LLMs how to work with his codebase. It’s not a new idea, but the fact that it’s worth documenting and sharing signals something: people expect their current setup to stick around for a while.

The file includes things like code style preferences, testing requirements, and architectural constraints. Stuff you’d normally communicate to a human developer once, then trust them to remember. With LLMs, you write it down once and it becomes part of every interaction.

This isn’t just Sanglard. The pattern is spreading because the cost curve stopped bending in our favor. If you’re going to use Sonnet instead of Opus to save money, you need to make Sonnet better at your specific task. That means better prompts, better context, better tooling.

What actually happens when the free lunch ends

Breunig’s observation cuts deeper than it seems at first. The whole LLM tooling ecosystem was built on an assumption: models will keep improving at the same price point. Startups could afford to have messy prompts and inefficient context loading because next quarter’s model would be 20% better anyway.

That assumption is breaking. Opus 4.6 exists. It’s measurably better than cheaper alternatives. But it costs enough that most teams are choosing to make do with Sonnet, or Claude 3.5, or whatever sits in the sweet spot of good-enough performance and acceptable cost.

This is actually healthy. The AI coding space was getting weird, with everyone optimizing for “use the newest model” instead of “build a system that works.” Now we’re back to normal software economics: you have a performance budget, a cost budget, and you figure out how to build something good within those constraints.

The tooling matters again

GitHub Copilot doesn’t use the absolute best model available. It uses a model that’s fast enough and cheap enough to run on every keystroke. Cursor and the other AI code editors are constantly making tradeoffs between model capability and response time. The companies winning in this space aren’t the ones with access to the best models. They’re the ones with the best scaffolding around decent models.

That scaffolding includes things like:

• Smart context selection (showing the LLM only the relevant parts of your codebase)
• Good prompt engineering (making sure the model understands what you actually want)
• Effective caching (not re-processing the same context over and over)
• Thoughtful model selection (using the expensive model only when it matters)

Breunig put it simply: “we started to think about what work went where.” Which model gets which task. Where the expensive Opus calls are actually worth it versus where Sonnet is fine.

This feels like a maturation. The free lunch era was fun, but it produced lazy tooling. Now we’re building systems that have to actually work well, not just work well enough until the next model drops.

The Anthropic revenue numbers show this isn’t hurting the industry. Developers are still spending money on AI coding tools. They’re just spending it more carefully, on solutions that prove their value rather than just riding the capability curve upward.