How Theo Cut a $2,000 AI Coding Run Down to $150

You're not prompting an AI anymore. You're configuring one. That distinction sounds subtle until you watch a developer clear a month of stalled work in three days for roughly $150 — and realize the secret wasn't the model, it was how he set it up to think.

That's the core argument Theo, the developer behind the T3 stack and tools, makes in a recent 43-minute walkthrough of his workflow with Claude's Fable 5 model. It's worth taking seriously, not because every claim holds up perfectly under scrutiny, but because the underlying approach points somewhere interesting about where software development is actually heading.

The Model Isn't the Variable — Your Configuration Is

When Fable 5 became available to subscribers, Theo ran it the way most developers run a new AI model: by reusing the prompts and habits that worked on the previous one. The results were fine but not transformative. What changed everything, he says, wasn't learning Fable's capabilities — it was spending an hour rewriting a configuration file.

Claude Code, the development environment Theo uses, lets you maintain a file called CLAUDE.md — think of it as a standing memo to the AI about how you want it to behave, what tools it has access to, and what your preferences are before you even start a session. Most developers treat it as a lightweight settings file. Theo treated his as a policy document.

"This model isn't a better Opus," he says in the video. "If you take prompts that worked for Opus and you give them to Fable, it's not going to be much better. The difference in this model isn't just how much smarter it is or how much better the code is — it's how much further it can go."

That distance comes from what Fable can do once it has clear instructions about how to work. In Theo's setup, the AI doesn't just write code — it routes tasks to other AI models based on what each one is good at, spawns sub-agents to handle parallel workstreams, and gates its own merges on approval from automated code review tools. Theo specifically mentions using Bugbot, Macroscope, and Code Rabbit — all established AI code review tools — as the gatekeepers his agent had to satisfy before merging anything. No human sign-off required for staging; production stayed behind a human gate throughout.

The Reasoning Slider Problem

Here's a detail that matters for anyone paying AI bills: Claude Code includes a setting that controls how hard the model "thinks" before responding — a reasoning intensity slider ranging from low to max. The intuition is that harder problems deserve more reasoning. The reality, according to Theo, is that the higher settings tend to make the model worse.

Claude Code lets you configure how hard the AI thinks at each step — and thinking harder costs significantly more money. What Theo found is that the highest settings — "X high" and "max" — cause the model to second-guess itself through repeated loops, producing over-engineered code with too many changes for what the task actually required, at costs dramatically higher than necessary. He says every user he spoke to who was burning through their budget unexpectedly had these settings turned up.

His recommendation: leave it on "high" and don't touch it. Not because high is the safest middle ground, but because it's genuinely the most effective setting for the kind of extended, multi-step work where Fable earns its reputation.

Routing Cheap Models for Expensive Work

The more consequential cost management move was teaching Fable to act as an orchestrator — assigning tasks to cheaper, more specialized models when the job doesn't require Fable's capabilities.

Model routing isn't a new concept in software architecture. What's changed is that you can now describe your preferences in plain language and have the orchestrating model internalize them. Theo's CLAUDE.md ranks the available models across three dimensions he cares about: intelligence (how hard a problem can it handle without supervision), cost, and what he calls "taste" — code quality, API design sensibility, UI judgment.

GPT-5.5 via the Codex CLI, he explains, scores high on intelligence and low on cost for his usage tier, but low on taste — "it writes TypeScript like a Python dev," which is a precise and damning critique if you've ever had to clean up that kind of code. Fable scores high on both intelligence and taste, but its cost is significant. So the system he built routes bulk mechanical work — log analysis, data migrations, reading large specification documents — to GPT-5.5, while reserving Fable for anything that requires judgment about how the code should look and behave.

The result of a 5.5-hour unattended agent run across a multi-week backlog: approximately $150 in compute, by Theo's account, spread across both his Claude Code and Codex subscriptions.

"Let's Yolo a Little Bit"

At the center of the most interesting section of Theo's walkthrough sits a phrase that deserves more attention than he gives it.

He had 16 open pull requests — proposed code changes — sitting stale in his Lakebed project, ranging from nearly finished to totally obsolete. He asked Fable to triage them, read the results, approved the plan, and then said: "Let's yolo a little bit."

What followed was an instruction set that gave the AI explicit permission to create branches, rebase code, merge pull requests, and close stale work — all autonomously, over the next five hours.

A professional developer's quality-control philosophy, summarized with a meme. Is that alarming? Somewhat. Is it also honest about how this actually works in practice? Also yes — and that combination is worth sitting with rather than dismissing.

The safeguards Theo had in place were real: Fable could only touch staging, not production; automated reviewers (including the AI code review tools mentioned above) had to approve each merge; and Theo checked GitHub periodically throughout. When he stress-tested the result afterward — spinning up additional agents to probe the new features and old ones — he found essentially nothing that needed fixing. He's candid that he was surprised.

"I burned way more tokens trying to verify the work that Fable did here than I burned getting Fable to do the work," he says. "And it was all good. There was nothing to change."

The honest question that raises: if verification agents found nothing wrong, does that validate the approach, or just mean the verification wasn't adversarial enough? Theo acknowledges he might not be pushing the model hard enough. That's a more interesting admission than the productivity numbers.

What This Looks Like From the Outside

There's a pattern worth naming here, because it shows up every time a major productivity tool makes a genuine leap. The people getting the most out of AI coding assistants right now are not the ones using the best model — they're the ones who have spent real time configuring how that model behaves, what it has access to, and what decisions require a human in the loop.

The CLAUDE.md file, the skills definitions, the model routing logic — none of this is difficult to implement. But it requires a different mental model than "chat with a smart AI." It's closer to writing a job description and an operating procedure for a contractor you'll never meet. The developers who are getting months of backlog shipped in days aren't prompting better. They're managing differently.

Theo's workflow, taken seriously, is less a demonstration of AI capability than a demonstration of how much leverage a single developer can get from one hour of configuration work. The models are tools. The configuration is the craft.

That may be the most useful reframe for anyone watching this space from outside the developer community: the AI is not the product. The system built around it is.

---

By Bob Reynolds, Senior Technology Correspondent, BuzzRAG