Spending $200K to Test GPT-5.6: Have AI Coding Assistants Reached a Tipping Point?

Well-known developer and tech blogger Theo (t3.gg) shared a remarkably rare first-hand account in his latest video: over the course of a month and a half with early access to GPT-5.6, he burned through roughly $180,000 to $240,000 worth of inference compute, pushing the model to its limits across 67 different projects. He was explicit that this isn't a review — it's a field report of "what I actually used it for."

A Month and a Half, $200K: Just How Extreme Was This Test?

Theo admitted that this level of usage is far beyond any normal use case. "Nobody should be doing this every month," he said. The reason he went so aggressive was simple: OpenAI gave him near-unlimited credits, and he wanted to find the model's ceiling.

Worth noting: he emphasized that OpenAI did not pay him for this content, and he continues to pay the full $200/month subscription out of pocket. LLM inference is typically billed per token, with GPT-series API pricing split between input and output tokens. "Fast Mode" is a higher-priority, lower-latency inference channel that often costs several times the standard rate. At Fast Mode pricing, many individual tasks ran into the tens of thousands of dollars — one single run consumed 71.2 billion tokens, totaling roughly $91,000 at approximately $12–13 per million tokens, consistent with GPT-4o-level high-priority API pricing. He also noted that dropping Fast Mode nearly cuts the cost in half, and the $200/month plan itself already includes roughly $14,000 worth of Codex inference credits per month — controlled through usage caps rather than unlimited access, meaning day-to-day coding assistance for most developers falls well within subscription coverage.

From "Getting Lost" to "Staying on Task": The Core Difference Between 5.6 and 5.5

Theo believes GPT-5.6's most fundamental improvement over 5.5 lies in task persistence and intent comprehension.

"Task persistence" is essentially a combination of long-context window management and instruction-following capability. Early large models suffered from "context forgetting" in long conversations — as token counts grew, the model would weight earlier instructions less, leading to task drift or stalling. He described 5.5 as something that "would get lost and then just stop" — if the context picked up incorrect information, you'd have to start a new thread. That's a textbook example of the problem. GPT-5.6 doesn't have this issue at all. He can let a thread "run forever" without errors, suggesting significant improvements in long-context retrieval, intermediate state tracking, and error recovery — all closely aligned with the field's current focus on agent reliability.

The most extreme example: he kicked off a large task and the model ran continuously for over 20 hours without any intervention until it finished. This "workhorse" stability made his previously underwhelming Slash Goal feature feel meaningful again — though he later found he barely needed it, since the model could sustain itself for hours on its own.

The gap was equally stark in sub-agent orchestration. This is a core pattern in multi-agent systems: an "orchestrator" breaks down complex tasks into subtasks and dynamically dispatches them to specialized agents for parallel processing, then aggregates the results. GPT-5.5's failures in this scenario — context management failures when maintaining multi-threaded task state and handling async result callbacks — were the underlying cause of the "confusion and getting lost" Theo described. He had previously shown loops where the model automatically opened threads to review PRs; he later admitted those were all done by 5.6 and manually passed off as 5.5 at the time. When he actually tested the same prompts on 5.5, "it just got confused and lost." GPT-5.6's ability to reliably serve as an orchestrator has significant implications for building automated DevOps pipelines and enterprise-grade AI tooling.

AI Operating Computers: A True "We're Actually Here" Moment

If one thing completely changed Theo's perspective, it was GPT-5.6's computer use capabilities — especially browser control. He had previously been extremely skeptical of AI operating computers. Taking screenshots, manually moving a mouse to coordinates, clicking, waiting — why would that ever be faster than a human?

AI Computer Use is a major direction in current agent research. Core technical approaches include: screenshot + coordinate mapping (using vision models to identify screen elements and output click coordinates), DOM parsing (reading webpage structure directly rather than screenshotting), and Accessibility API calls (using the OS's Accessibility interface). Anthropic was first to open up Computer Use capabilities with Claude 3.5 Sonnet in 2024, generating widespread attention.

But 5.6 changed his mind. He shared a particularly dramatic example: he had a machine with a corrupted boot partition from pulling an SSD, stuck in a grub interface that could only run memory tests. He described the situation to the model, and it "said hold my beer," rebooted several times, entered the grub shell, correctly booted the system, then opened a terminal via remote control and repaired the boot partition — entirely autonomously. The stability GPT-5.6 demonstrated here — handling tasks where context needs to span across physical reboots — is a direct demonstration of the "act-observe-decide" loop reliability.

He called it "one of the strongest 'holy shit, we're actually here' moments," because tasks like this normally require extensive research, patience, and risk tolerance. He also built a bootable Codex USB drive that, when plugged into any machine, provides a remote access environment with Codex pre-installed. Combined with a GL.iNet remote KVM (a hardware device that forwards keyboard, display, and mouse signals over IP), he achieved automated configuration of an entire server room — theoretically enabling fully automated operations on bare-metal machines that can't be reached via SSH.

Large-Scale Code Rewrites: React Native, Swift, and Rust Experiments

Theo spent a lot of time on what excited him most — large-scale AI code rewrites.

React Native is Meta's cross-platform mobile app framework that lets developers use a single JavaScript/TypeScript codebase to build both iOS and Android apps. AppKit is Apple's mature macOS native UI framework from the Objective-C era, while SwiftUI is the declarative modern framework introduced in 2019. Fully migrating a React Native app to native Swift typically requires weeks to months of engineering effort, given the vast differences in component models, state management philosophy, and platform APIs.

In the T3 Code project, he had GPT-5.6 rebuild an entire React Native mobile app twice from scratch — once in AppKit/Swift and once in SwiftUI. What shocked him was that both native versions were fully functional and end-to-end usable, and each took only 2 to 4 hours — a test not just of code generation, but of cross-domain comprehension across radically different framework paradigms.

Even more aggressive were two Rust rewrite experiments. Rust is a systems programming language initiated by Mozilla, known for memory safety, zero-cost abstractions, and extremely high performance — rapidly gaining ground in high-performance scenarios as a replacement for C/C++. TSGo (TypeScript to Go transpiler) is a tool that transpiles TypeScript code to Go; rewriting its Go port in Rust means implementing a complete TypeScript syntax parser, type system modeling, and code generator — top-tier complexity in compiler engineering. He first did a complete Rust rewrite of Hermes Agent, producing a version that uses only about 15MB of memory, capable of independently responding, creating threads, and calling models. After running for about a day it was verified as functional. He then tackled an even more ambitious target: rewriting the TypeScript-to-Go transpiler (TSGo) in Rust.

The results were thought-provoking. He did get a 100% functional transpiler that was up to 18x faster than the Go version, with a codebase of nearly 200,000 lines of Rust spread across 29 crates. But he also honestly cited the evaluation from another model, Fable: this was "a broad prototype with only a tiny verified slice," roughly 15–20% of the way to being a usable tool and only 5% of the way to truly replacing TSGo, with tests currently failing. This exposes a classic problem with AI-generated large codebases: there's a massive gap between surface-level completeness (line count, module structure) and actual usability (edge case coverage, test pass rates, production validation). This honest self-assessment reveals the typical trap of large-scale AI-generated code — "looks highly complete, but unproven" — and is one of the core challenges that AI-assisted software engineering needs to solve.

Frontend and 3D Generation: Real Progress, But Far From Mature

Theo made a point of throwing some cold water: GPT-5.6 is not a "magically perfect" frontend model. The terminal token tracker UI it generated was "extremely ugly," and he ultimately had to redo it with Opus 4.8. His verdict: 5.6 is "more controllable and has less terrible default aesthetics," but "is not a good frontend model by any stretch."

On 3D game generation, he had the model rebuild a 3D version of a small game called Fish Slop. The model generated the 3D environment, ground rocks, and textures on its own — some textures were actually better than Grok's output, but the rocks were noticeably worse, and the monster and fish models were "absolutely hideous." He described 5.6's understanding of 3D as "very strange" — not yet at a publishable level, but improving fast enough that he'll keep watching this space.

Conclusion: This Model Made Him "Think Bigger"

Theo kept coming back to one feeling: GPT-5.6 reignited his excitement and made him want to build more and think bigger. He even partially credited the model for the "think bigger" themes in his recent talks at CascadiaJS and AI Engineer conferences — "the simple stuff is too easy for it. I have to push it toward bigger, harder things."

One important caveat: this article is based on a single source (Theo's t3.gg video), and he explicitly stated that he hasn't read any other reviews, hasn't looked at benchmark data, hasn't tested the Pro version or in-app ChatGPT performance, and doesn't cover pricing or rate limits. He promised follow-up content including a formal review, a comparison with Fable, and everyday usage tips. This account is best understood as "one power user's authentic experience sample" rather than a comprehensive verdict on GPT-5.6.

Even so, the signals it reveals are clear enough: AI coding is evolving from "an assistant that needs careful hand-holding" to "a workhorse that can independently grip complex tasks for hours or even days." And the maturation of computer use capabilities may be the next tipping point that truly transforms developer productivity.

Key Takeaways