UltraFast Hands-On: Blazing Speed, Wallet-Destroying Prices

One developer spent over $500 just to answer a single question: when an AI model's code generation speed jumps from 30 tokens per second to 300, what actually changes about the programming experience? The conclusion is contradictory — UltraFast is addictive to use, yet so expensive that almost no one should touch it.

When Inference Speed Is No Longer the Bottleneck

UltraFast runs on the actual Astra model (the author initially assumed it ran on Cerebras hardware, but later confirmed it's an NVIDIA-based optimization), with real-world throughput measured between 320 and 340 TPS. By comparison, standard speed sits at about 30 TPS and Fast mode at roughly 60 TPS. That means a code generation task that once took 10 minutes now completes in just over 30 seconds.

This speed gap doesn't just mean "less waiting" — it fundamentally transforms how you work. The author describes a scenario where he asked the model to switch his app to light mode and make it "more fun," then watched the page update in real time inside his dev server. No cuts, no skipping ahead — an experience that simply didn't exist in traditional AI-assisted programming.

There's an interesting technical nuance worth noting: when inference drops from 10 minutes to 30 seconds, operations that were once negligible — git commands, build steps, tool calls — suddenly account for a meaningful share of total runtime. The author adjusted his system prompt specifically to discourage the model from calling tools that "take a few seconds" (like auto-refreshing the preview browser), because those operations can now literally double the wall-clock time.

TPS (Tokens Per Second) is the core metric for measuring LLM inference speed — it represents how many tokens the model generates per second. One token roughly corresponds to 0.75 English words or about 1.5 Chinese characters. Typical hosted model output speeds range from 30–80 TPS, while human reading speed corresponds to roughly 10–15 TPS. This means even "normal" models already output faster than humans can read — but for tasks like code generation, where you need to wait for a complete, runnable result, total latency can still reach several minutes. 320–340 TPS means the model outputs more than 20× faster than the human eye can follow, making it possible to literally watch code refresh in real time rather than waiting for a static final result. Cerebras is an AI hardware company focused on its Wafer Scale Engine architecture, which is particularly well-suited for low-latency, high-throughput inference — one of the few commercial solutions capable of delivering hundreds of TPS. NVIDIA's optimization approach typically leverages inference frameworks like TensorRT-LLM, squeezing maximum throughput from traditional GPUs through quantization, operator fusion, and similar techniques.

The Price: A Breathtaking 6× Premium

Astra itself isn't cheap on the API — output costs $50 per million tokens. Switch to UltraFast and that number jumps to $300 per million. For long-context projects, it climbs further to $450 per million. Cache read costs follow suit: standard cache reads rise to $6 per million (already more expensive than regular reads on most other models), while cached reads under long-context pricing hit a jaw-dropping $75 per million.

The author shared several real data points to quantify this insanity:

• Reviewing two PRs, each under 100 lines of code, cost approximately $600
• Building an app with UltraFast cost $46.32 in actual spend; running the same task on standard Astra via API would have cost $7.72; and completing the same work with Sol 6.1 at normal speed would have cost just $1.10
• That works out to UltraFast costing more than 40× as much as Sol 6.1

The $500/month UltraFast plan comes with roughly $1,000 in weekly credits — but in UltraFast mode, that allowance burns out in just 2.1 hours. The author's real-world test: sending two prompts (one build task taking 38 seconds, one light-mode change taking 16 seconds) dropped his credits from 38% to 37% — less than a minute of work consumed 1% of his budget. Even OpenAI employees now have to "request approval per task" to use UltraFast, because even their internal compute can't keep up with demand.

Understanding these prices requires a bit of context. LLM API pricing is typically split between input tokens and output tokens — in code generation scenarios, output tokens drive the bulk of the cost, since generation is far more compute-intensive than reading. Cache reads refer to when the same context (e.g., system prompts, long files) appears repeatedly across multiple API calls; providers cache it to reduce redundant computation, typically pricing it at just 10–25% of standard input costs. UltraFast turns cache reads from a cheap operation into an expensive one ($6/million, or even $75/million), which means long-context projects — precisely the scenarios where speed delivers the most value — face exponential cost inflation. The reason the $600 PR review figure is so shocking is that code review involves repeatedly reading large amounts of context; the higher the cache hit rate, the more expensive it becomes under UltraFast.

Why It's Still Captivating

Despite the absurd cost, the author admits that "once you get used to UltraFast, everything else feels painfully slow." The real value isn't time savings — it's the way UltraFast reactivates a long-lost sense of flow state.

The author used his app Slopalytics as a case study. He ran the same task in parallel with Opus 5.5 and Astra UltraFast: Opus took about 15 minutes to produce a usable first draft; UltraFast got there in under two minutes. Opus's initial design was noticeably better — but by the time the author got to see the Opus version, the Astra version had already been through several rounds of real-time feedback and pulled ahead.

The key is the shift in interaction pattern. With Opus, his habit was to "read the output, list 20 changes, send them, then wait 5 minutes to 2 hours." With UltraFast, he sent 50+ messages in a single thread — the timestamps show he sometimes sent five prompts in four minutes, with each reply coming back within a minute or sometimes in just 18–20 seconds. The pace was fast enough that "you literally don't have time to get distracted," which led him to come up with UI interaction patterns he never would have thought of otherwise — things like model comparison views and charts that show diffs on hover — all sparked in the moment while watching the interface update live.

He even said: "I probably wouldn't have finished Slopalytics at all without UltraFast." Astra's design capabilities are objectively weaker than Opus or Fable — but because he could iterate in real time while staying in the loop, he ended up with a better UI. Design is fundamentally about user perception, and UltraFast gave him more time to actually perceive.

Flow state is a concept introduced by psychologist Mihaly Csikszentmihalyi, referring to the optimal experience of complete absorption in an activity — a state of intense focus where time seems to disappear. One of the key conditions for entering flow is immediate feedback: the shorter the delay between taking an action and seeing the result, the easier it is to maintain continuous attention. In traditional AI-assisted programming, a 5–15 minute wait is enough to send developers reaching for another browser tab, breaking their train of thought and forcing them to mentally reload context every time the output arrives. UltraFast compresses that delay to 18–38 seconds — close to the natural rhythm of human thought — allowing developers to iterate continuously within the same cognitive state. This is the underlying reason the author was able to fire off 50+ messages in one thread and spontaneously generate unexpected UI ideas. The principle echoes game design's concept of "responsiveness": users perceive lag above 100ms as "stuttering," and the "cognitive stutter" threshold for programming tools is roughly on the order of a few minutes.

Should You Use It? The Real Hope Lies Ahead

The author's position is unambiguous: almost no one should use UltraFast right now. It's too expensive, burns through credits at a ludicrous rate, and makes the $500 plan feel completely pointless. He thinks OpenAI was flat-out crazy to release it at this price point, and even crazier to make it a one-click toggle — just like the highest reasoning tier, once you give users a dial they'll turn it all the way up, which leads to a lot of terrible decisions (Primeagen bought the $500 plan and burned through half his credits in an hour).

So what's the point of it existing? The author's take is this: UltraFast isn't meant to be used — it's meant to be experimented with. It lets a small number of token-burning early adopters experience this kind of fluid, real-time workflow, paving the way for a better future — one where you can access this kind of speed at a price that doesn't make you sick.

That hope isn't wishful thinking. The video mentions that Tebow has publicly confirmed Sol 6.1 UltraFast is coming (likely based on Cerebras or an NVIDIA optimization). The author ran the numbers: if Sol 6.1 UltraFast carries the same 6× price multiplier, it would not only be 10× cheaper than Astra UltraFast — it might actually be cheaper than standard-speed Astra. At that point, the $500 plan could shift from "overpriced gimmick" to genuine value.

For practical guidance right now:

• Only use it when it's "free money" — for example, if your account is about to reset and you have a large credit balance to burn
• It could theoretically be used for high-priority incident response, but even then, it's hard to justify unless "money is no object"
• Don't upgrade to the $500 plan just for UltraFast — at least not yet
• The author himself uses Opus for serious daily work, and zeroing out his Codex credits doesn't affect him at all

The author also teased a separate video discussing whether the $200 plan — which includes Sol 6.1, Astra, and Fast mode, but not UltraFast — is worth it. For most developers, that's probably the more realistic option anyway.