I stopped comparing models after Opus 5.5

A developer's outlook on Astra, Fable, and Opus 5.5; or rather, a developer's outlook on why Opus 5.5 is the best model for daily coding purposes.

Originally, this blog post was supposed to be a comparison article titled "Opus 5.5 vs Astra or Fable". I have been using Opus 5.5 for a while now, and honestly, I'm in a weird situation: I don't really have a need for other models when it comes to coding or architecture. I have officially developed fully scalable and launchable apps with Opus 5.5, and switching to a different model for the first time ever has never crossed my mind; here's why.

The verbosity problem: great code, buried answers

I think a good way to start this off is to talk about the bad parts of Opus before diving into all the amazing things that it can achieve and how I have been using it.

First, I don't know if this is my ADHD brain or not, but Opus has terrible explanations and outputs. I even went as far as downloading GitHub repos like i-have-adhd to consistently modify Claude's output just because it felt too detailed and complex to read. I think the output of Claude Code is old-fashioned in a sense. If you are really deep into a coding problem and you're vibe coding alongside it, Opus's precision can be a useful tool. In my mind, though, that methodology is an outdated way to vibe code. I don't think a lot of people are looking in-depth at code anymore and being ultra-technical while writing it.

Meanwhile, when I went back to Astra and asked it a question, it answered with a clarity I enjoyed. It wasn't ultra-technical, it summed up the points at a high level in a way that worked for my role overseeing the project. Software engineers keep moving to a higher level of understanding or generalization of their projects, and the outputs of our agents should be able to meet us where we are. This doesn't mean that software engineers don't understand what they are coding or that they are less technical; they're just exercising their technical skills in different ways. Astra's output, therefore, sets it apart for engineers of the AI age.

I thought the difficulties I faced with outputs were related to my ADHD. Turns out it's not just my brain. That i-have-adhd repo has 57.2k stars on GitHub and its whole description is "A skill to stop your coding agent from burying the answer." That means 57,200+ other users were having the same difficulty sifting through responses as I was. On Hacker News, one developer wrote: "Opus 5.5 writes whole essays at the end of the turn, with the important actionable steps somewhere at the bottom." They had switched Claude Code's output style to Concise "with no apparent effect." Same comment: "Its explanations often appear overcomplicated for simple concepts."

The funny part is Every.to scored Opus 5.5 as the most readable prose they've seen from Anthropic or OpenAI. So it's not that the sentences are hard to read. Instead, it's that "the writing is easier to read but often buries the point." The point is in there somewhere, you just have to dig for it.

Despite this assessment, many engineers prefer Astra's style. Kieran Klaassen at Every.to moved to Opus 5.5 as his daily driver and still preferred Astra for technical writing. In Dan Shipper's tests, "Astra won on headlines, first sentences, and idea order." OpenAI liked Astra's style enough that they pushed it down into Sol and Luna, promising "more clarity, less jargon, fewer odd turns of phrase, fewer low-value details, and slightly shorter answers overall without losing substance."

So what exactly does Opus 5.5 do right?

Design philosophies: autonomous completion vs. constant clarification

I think Opus 5.5 is designed to do it all. Unlike GPT Sol and Luna, which were always ranked as the cheapest possible input compared to their output, Opus 5.5 scored higher. Luna and Sol ask a lot of clarifying questions. Their core design philosophy is to code alongside you and to never do something that isn't stated.

Astra and Opus have a different philosophy: they are testing the bounds and running toward artificial general intelligence (AGI). They want to one-shot an entire prototype or project without you even having to clarify anything. Yes, they ask questions, too. However, in my experience with Sol and Luna, if one small thing is not clarified in my prompt, I will get a question back. This is not the case for Astra and Opus. They operate first, ask questions second. They are wildly different models at their core, and comparing these models to Luna and Sol isn't fair.

OpenAI's own docs describe that Astra "uses the context it has to fill in routine gaps and asks focused questions when the answer could change the outcome." It's not wasting time asking about what color you want that element to be, it's building systems then getting your opinion on how to resolve any perceived gaps.

Unlike Astra, Sol has the opposite reputation problem. It creates plans, but they don't always come to fruition. There's even an open GitHub issue on the Codex repo that suggests "Codex keeps stopping or losing the task before the work is done" and the models in the reporter's logs are gpt-6.1-sol and gpt-6-sol.

Opus, on the other hand, has "a tendency to do the most, which means it runs for minutes or hours," according to Dan Shipper.

Price-wise, they're not even in the same bracket either. Sol is $2 in and $10 out per million tokens and Luna is $0.10 and $0.50 according to DataCamp. Opus 5.5 is $4 and $20, according to Anthropic.

Pricing, quotas, and real-world task economics

Now let's get to the main reason why Opus is outperforming all these other models and why the general public has shifted toward it: cost and quotas.

Opus 5 was expensive (and Astra still is), but Opus 5.5 made a huge breakthrough on cost. Personally, I have been using my Claude Max 20x plan every day (and night) and I can't seem to run out. I think the only way I could possibly run out of tokens is if I didn't sleep or if I automated something on top of Claude Code. Saying this, I don't even use Claude Code optimally either. Every now and again I get impatient and don't "own my output," meaning I don't think hard about steering the model. Sometimes I even ask it to spin up sub-agents and steer itself. Whatever the case may be, I have never run out of tokens. Cleaner engineers than I could potentially sit on years of tokens and never burn through them all.

Other people are saying the same thing. On one Ask HN: Is Opus 5.5 another step change? thread, one person wrote: "It's the first model that I feel I can just use freely without crashing into the 5 hour limits." Another said it "burns Claude subscription quota much more slowly than Fable." It seems to work much more efficiently for users, with few reporting higher prices (and in large part because they had "Pro" on).

The pricing around Opus 5.5 feels solid, but anecdotal evidence is just that — anecdotal. Data tells the real story. Below are the prices per million tokens for many popular models out now.

API price per million tokens (input / output)

Sources: Anthropic, VentureBeat, DataCamp, Startup Fortune

The input and output costs of Opus 5.5 beat Opus 5, Fable 5.1, and GPT-6 Astra line-by-line. But token price is only half of the story — what matters more is how many tokens a model burns to finish the job. Startup Fortune compiled cost-per-task data on Terminal-Bench 4.0. Here's what they found.

Cost per task on Terminal-Bench 4.0

Even at its highest burn rates, Opus 5.5 was just shy of 50% of the cost per task of Astra, according to these measures.

Not every benchmark agrees, though: Lindy ran the numbers and found Opus 5.5 "averages about 119,000 output tokens per task to Astra's 27,000." So at max effort, Astra is actually the cheaper model per task ($3.26 against Opus's $5.98). At medium effort, which is Opus's default, Opus is about 13% cheaper.

Per-task pricing only matters if you pay per token, though. A developer on a Claude Max plan doesn't. For them, the question is how much work fits under the limit, and that's where the numbers really add up. Wokey measured 36 real Max 20x accounts and found a week of use averaged about $1,751 at API prices. That's roughly $7,587 a month on a $200 plan. Opus 5.5 also stretches the limit further: Wokey found it uses about 0.6x the limit per token of other Opus and Fable models. Anthropic raised 5-hour limits by 20% on launch day, noting Opus 5.5 "goes 25% further within limits."

OpenAI's matching plan is ChatGPT Pro at $200 a month, which OpenAI calls Pro 20X, and new customers can't buy it right now. OpenAI paused new sign-ups and upgrades on September 10, a week after Astra launched, citing demand for Astra. The tier still open is Pro at $100 (Lindy lists it at 5x Plus usage). OpenAI also doesn't publish Astra limits as fixed numbers. Its pricing page estimates 5 to 45 local Astra messages per five-hour window on the $20 Plus plan, and says Pro has no five-hour limit, though weekly limits may apply. So a Max 20x user who wanted to move to Astra at the same price can't do it today.

Developers who do pay per token are still spending on Opus. OpenRouter posted that Opus 5.5 is "the #1 model in share of spending across the platform." That's by money spent. By raw token volume, it sits further down, since budget models push far higher token counts. So on OpenRouter, Opus 5.5 is where the money goes, even though cheaper models handle more of the tokens.

The "one-shot" application myth

If you haven't had the chance to use Opus or Astra, you will see a lot of social media posts showing these behemoth models "one-shotting" entire projects or prototypes. These are fun messages for social media; they are not viable in practice yet. AI at first glance looks a lot better than it is, but when you dig a little deeper, usually there are notable cracks in the facade.

Maybe something really small like a basic calculator application can be one-shotted. But if you increase the complexity even slightly — say, building something like the Mote game I built with Blocks.ai — it will not achieve this in a single generation. There is a ton of complexity that goes into production applications, and current models and harnesses are not ready to build them top-to-bottom in one pass.

Even the most positive reviews back this up. Every.to had Tyler Nishida give Opus 5.5 one prompt for a 3D golf game, and it worked. That's about the maximum scope possible for a single turn.

Even Anthropic's customer Quantium reported that "a complex coding task that previously took 38 prompts over four days came in at 11 prompts over three hours." That's a massive jump — it's still 11 prompts, not one.

Developers overall aren't buying into the one-shot narrative either. Sonar surveyed 1,149 developers for their 2026 State of Code report, and 96% said they don't fully trust AI-generated code to be functionally correct. Only 48% said they always verify code before committing. On Hacker News, someone posted that they had Opus 5.5 running sub-agents for 20 hours without input, to which another developer replied: "At that point the hard part is just trusting it didn't quietly go off track somewhere imo."

Ultimately, while efficient, Opus 5.5 — and any current model, for that matter — is not a perfect "one-shot" solution yet.

Generation speed vs. real work velocity

Another measure that affects our day-to-day as developers is execution speed. Opus 5.5's execution speed is noticeably improved from its historical counterparts. Anthropic reports that Opus 5.5 outputs more than 30% faster than Opus 5. Anecdotally, one user on Hacker News noted that "the time-to-first-token seems dramatically better in Claude Code compared to Fable 5.1/Opus 5."

However, faster streaming speed doesn't always equal faster task completion. Every.to gave Opus 5.5 10 minutes to make a client training schedule; it "prepared training materials and ran out of time without producing the schedule," effectively failing the timed task. This doesn't make Opus 5.5 obsolete, but it does mean that you should heed Every.to's warning to builders that "the budget is yours to set, because it won't [set it for you]."

So really, why did I stop model hopping?

A lot of developers have stopped comparing models altogether, either because they rotate through them for different use cases or because they're just tired of it. But for me, the question of "Opus 5.5 vs Astra" is solved. I don't need another model right now, and switching hasn't even crossed my mind. Opus 5.5 is efficient, cost-effective, and generally does what I asked it to do with ease.

That said, workflows remain nuanced across the industry. Mike Taylor at Every.to still prefers Fable "as a writer and for the bigger, meatier problems." Kieran still uses Astra for technical writing. Use whatever workflows and models work best for you and your tasks at hand.

For my workflow, I stand by my initial takeaway: Opus 5.5 is the superior model, and I don't plan on switching anytime soon.

Build something with Blocks.ai

The best way to see this setup in action is to try Mote from the Blocks Lab.

Blocks is a private network layer that connects AI agents across different frameworks, providers, and runtime environments. It allows you to make your agents securely reachable without opening inbound ports, setting up public tunnels, or managing firewall rules. Your application can discover other agents on the network and invoke them seamlessly via SDKs available for TypeScript and Python.

Check out the Blocks documentation, fire up Claude Code, and see how far Opus takes your next project. Just remember to guide it — don't expect it to one-shot it.