Blog / · 5 min read
Claude Sonnet 5: the "good enough" model is now the real story
Sonnet 5 lands in Claude and GitHub Copilot. Not the flashiest model, but probably the one that will run most real developer workflows.
Anthropic released Claude Sonnet 5 on June 30. Not Opus. Not the model that ends up in benchmark screenshots on LinkedIn. Sonnet.
And that is exactly why the release matters.
Frontier models make the demo. Sonnet models make the bill. They are the ones you put inside agents that run every day, inside Copilot, inside internal tooling, inside small scripts that open PRs while you work on something else.
The question is not: “is Sonnet 5 the best model in the world?”
The more boring question is the important one: is it reliable enough to become the default without feeling like a discounted version of the real thing?
The real change: Sonnet gets stronger on long tasks
Anthropic positions Sonnet 5 as better at coding, tool use, and multi-step workflows. That sounds generic. But it is exactly where mid-tier models still failed too often.
Not when writing one function. Everyone can do that now.
The issue was follow-through:
- reading three files before changing the fourth;
- remembering a decision made ten minutes earlier;
- rerunning tests without being reminded;
- not redesigning the architecture in the middle of a bugfix;
- calling tools without producing malformed JSON every few runs.
A cheaper model that holds those behaviors better changes daily work more than a premium model that gains three points on a leaderboard.
In a real agent workflow, you are not only paying for intelligence. You are paying for stamina.
Why GitHub Copilot matters here
The concrete signal is that Sonnet 5 also lands in GitHub Copilot: VS Code, Visual Studio, Copilot CLI, cloud agent, GitHub Mobile, JetBrains, Xcode, Eclipse. This is not a niche integration.
It means the model will be tested by people who do not read Anthropic release notes. Developers who pick a model, launch a refactor, and judge the diff.
That is harsher than a benchmark.
In a benchmark, failure is a red line in a table. In Copilot, failure is a stupid diff on a branch where you already had no time.
If Sonnet 5 holds up, it becomes the reasonable choice for 70% of work:
- localized bug fixes;
- medium refactors;
- test generation;
- PR review;
- internal scripts;
- understanding a codebase that is not absurdly large.
Opus remains for the moments where you need the expensive brain: messy architecture, security review, risky migrations, huge business context.
The trap of the cheaper model
I still distrust the “cheaper is better” narrative. A cheaper model mechanically encourages people to give it more work. That is where damage starts.
A very good Sonnet can make you forget it is still a probabilistic model with partial access to your system. It can write faster than you, but it does not own the responsibility of what gets merged.
The pattern is easy to predict:
- Sonnet 5 becomes the default.
- We give it longer tasks because it holds up better.
- We review less because “honestly, it is reliable”.
- A product decision disguised as a cleanup slips into the diff.
That is not an Anthropic problem. It is a workflow problem.
Models become good enough for us to lower our guard at the wrong moment.
My current routing
If I had to route work today, I would keep it simple.
Sonnet 5 by default for daily development. Not because it is perfect. Because it should have the best price / quality / latency ratio on recurring tasks.
Opus when the task has real architectural ambiguity or product risk. As soon as the work requires judgment, not just execution, I prefer to pay more for better analysis.
Haiku or a lightweight equivalent for classification, extraction, triage, small transformations. Sending Sonnet to do that is taking a taxi to cross the living room.
The difference is that Sonnet no longer feels like a compromise. Before, you picked Sonnet because Opus was too expensive. Now, you can pick it because it is probably the right tool.
What I will watch
Not the scores. The behavior.
I want to see whether it:
- breaks tool-call formats less often;
- knows when to stop because information is missing;
- avoids out-of-scope refactors;
- keeps better test discipline;
- produces reviewable diffs instead of 40-file novels.
That last point is underrated. An agent that codes “well” but returns diffs nobody wants to review is bad in production. Agent quality is also measured by the fatigue it leaves behind.
Early verdict
Sonnet 5 is not a glamorous announcement. It is better than that: an infrastructure announcement.
If Anthropic got it right, the model will disappear into workflows. We will not say “I used Sonnet 5”. We will say “Copilot prepared the PR”, “Claude cleaned the module”, “the agent passed the tests”.
That is real adoption.
Not the moment everyone talks about it. The moment nobody needs to name it anymore.
Sources
Keep reading