Pick Your Coding-Agent Model by Opportunity Cost — Why I Run Fable 5 Low and Codex 5.6 Sol Light for Speed

Developer Tadashi Shigeoka now defaults to lighter reasoning and speed settings on coding agents, running Anthropic's Fable 5 at Low reasoning in Claude Code and OpenAI's Codex 5.6 Sol at Light reasoning and Fast speed, which reached general availability on July 9, 2026. Shigeoka argues that choosing settings by opportunity cost, not token cost, speeds up daily work because faster replies let him read and fix code sooner, and that lighter settings do not reduce model intelligence, only the number of reasoning tokens spent.

Pick Your Coding-Agent Model by Opportunity Cost — Why I Run Fable 5 Low and Codex 5.6 Sol Light for Speed Tadashi Shigeoka /en/author/tadashi-shigeoka/ · Sat, July 11, 2026 Lately I’ve been deliberately dialing the model settings on my coding agents toward the lighter end. In Claude Code https://claude.com/product/claude-code I run Fable 5 https://www.anthropic.com/claude/fable at the Low reasoning level, and in Codex https://openai.com/codex/ I run 5.6 Sol https://openai.com/index/gpt-5-6/ at the Light reasoning level and the Fast speed level. That’s my default now. I used to lean the other way, reasoning that “if the model is this smart, I might as well let it think hard for the best possible result,” and I tended to pick the heavier settings. Over the past few months I’ve come to doubt that premise pretty seriously. It wasn’t some elaborate benchmark that changed my mind. It was the day-to-day feel of using these agents constantly. For all the extra time the heavier setting made me wait, the answer that came back wasn’t noticeably better. If anything, having the lighter setting fire back quickly, so I could read the result with my own eyes and fix it, let me move the day’s work forward faster. Put that feeling into words and it resolves into a single line: choose the model setting by opportunity cost, not token cost. Why Light Is My Default Now Let me be concrete about the current settings. In Claude Code I use Fable 5 at the Low reasoning level, and in Codex I use 5.6 Sol, which reached general availability on July 9, at the Light reasoning level and the Fast speed level. The thing to pin down here is that the reasoning level and the speed level are two separate dials. The reasoning level decides how many moves of thinking the model gets to spend, and in Codex it runs from Light all the way up to Ultra. The speed level decides, independently of that, how quickly the reply comes back. I have both of them tilted toward the lighter and faster end. Claude Code’s Low is a reasoning level in the same sense, sitting at the lighter end of the range Fable 5 can reach. The other thing that matters is that a light setting doesn’t mean a dumber model. Dialing down the reasoning tokens is not the same as dropping to a weaker, cheaper model tier. It’s the same smart model, just told to spend fewer moves thinking. So for code generation or investigation, the raw comprehension and the breadth of what it knows stay high, and only the reply gets faster. This sense of “same intelligence, more speed” is the premise underneath how I now pick settings. I’m not claiming light is always right. As I’ll get to, I flip to a heavier setting when the work is genuinely hard. But for the ordinary tasks that fill most of a day, drafting an implementation, fixing existing code, scaffolding tests, doing light research, starting from a light setting is currently the best deal I’ve found. The Speed-Versus-Intelligence Trade-off Choosing a reasoning setting is, at bottom, a question of where to strike the trade-off between speed and intelligence. Let the model spend more reasoning tokens and it takes longer, but there’s room for a more deeply considered answer. Spend fewer and it’s faster, but there’s room for the thinking to be shallow. The naive conclusion is that the more important the work, the more you should tilt toward intelligence. That naive view is exactly why I used to reach for heavier settings. If the capacity for deep reasoning is right there, leaving it unused feels wasteful. Even if it takes a bit longer, getting a higher-quality answer must pay off in the end. That’s what I believed. But this trade-off smuggles in a hidden assumption: that thickening the reasoning meaningfully reduces failures, or at least makes the nature of the failures better. That’s where things started diverging from experience. Even with the heavier setting, I still had to read the returned code myself and check it. And when I read it, the way it got things wrong looked much the same as with the light setting. The “intelligence-side payoff” I thought I was putting on the scale turned out to be far lighter than I’d assumed. The Shape of the Mistakes Barely Changes With Reasoning Tokens Here is the heart of it. Today’s high-intelligence models fail with much the same shape of mistakes whether you spend a lot of reasoning tokens or few. What do I mean? When a task you handed to an agent goes wrong, the failure tends to take one of a handful of recurring patterns. It misreads a premise in the instructions. It ignores the conventions of the existing code and brings in its own approach. The tests pass but the requirement is subtly missed. It drops a single boundary condition. These failure shapes show up with a strikingly similar face whether the setting is light or heavy. Thickening the reasoning doesn’t hand you safe code from some entirely different dimension. The frequency may drop a little, but the categories of failure don’t get swapped out. The practical consequence is that my review stance doesn’t change. The failure shapes I need to catch in review are the same for the light output and the heavy output. So the attention I bring to reading the code, and the angles I check, are nearly identical. In other words, a heavier setting does not let me skip human review. Review effort, the most expensive human cost of all, stays right where it is whether the reasoning is thick or thin. If that’s so, then what exactly is the wait time I’m paying for with the heavier setting buying me? If the failure shape is the same and review can’t be skipped, the extra reasoning tokens buy roughly “a slightly lower frequency.” That payoff is astonishingly small against the time I’m made to wait. The scale of the trade-off was tipped far further toward the speed side than I had thought. Decide by Opportunity Cost, Not Token Cost Let me restate that realization in the language of cost. When we pick a model setting, we’re weighing two kinds of cost against each other. - Token cost: the cost visible as a dollar figure, for reasoning tokens and API usage. The heavier the setting, the higher it goes - Opportunity cost: the value lost while a human sits idle waiting for the agent’s reply. The heavier the setting, the longer the wait, and the larger this grows When the conversation turns to the cost of generative AI, it tends to congregate around token cost, because it shows up as a dollar figure: so much per request, so much per month. But I’ve come to think the one that actually bites is the other one, opportunity cost. Since the failure shape doesn’t change and review can’t be skipped, what a heavier setting buys is small, yet the wait time reliably grows. During that stretched wait, a human’s thinking and judgment are on hold. That costs far more than the dollar figure on the tokens. So I decide model settings by opportunity cost, not token cost. I don’t pick a light setting to save on the token bill. If anything it’s the reverse: I’ll happily spend a few extra tokens if doing so cuts opportunity cost. The one criterion is minimizing the time a human’s hands are stopped. That’s where I set it. Here’s the whole line of reasoning as a single flowchart. php flowchart TD A "How to set the model for one turn" -- B{"Does the mistake shape<br/ differ between light and heavy?"} B -- |"Not much<br/ both caught in human review"| C "Review effort is the same" C -- D{"Then what changes?"} D -- |"Wait time wall-clock"| E "Time the human's hands are stopped" E -- F "Opportunity cost dominates" F -- G "Make light the default" B -- |"Intrinsically hard task<br/ design / deep debugging"| H "The shape can change" H -- I "Flip to a heavy setting" Opportunity Cost Is Hard to See Because Humans Are the Bottleneck Even granting that opportunity cost matters more than token cost, most teams don’t treat it that way, and the reason is that opportunity cost is hard to see. Token cost lands on an invoice as a dollar figure. But “the value a human lost while waiting on the agent” never arrives as a bill anywhere. Because it’s invisible, it gets quietly discounted. That’s the tricky part. So how can I be sure the invisible opportunity cost is genuinely large? The answer follows self-evidently from a fact about how development works today: the human is the bottleneck. Now that the speed of writing code is no longer the constraint, thanks to the agents, what sets how far you get in a day is the speed at which a human decides what to build, reads the output, evaluates it, and ships it with accountability. Since the ceiling on throughput sits on the human side, every second that bottleneck is stalled means a second of stalled throughput for the whole system. From this vantage the true nature of opportunity cost snaps into focus. While the agent ruminates under a heavy setting, the human, who is the bottleneck, has their hands stopped. Nothing hits throughput more directly than stalling the bottleneck. Token cost is merely the dollar figure on a non-bottleneck part, the machine’s processing. Whether it’s worth stalling, or padding, the bottleneck human’s time can only be measured in opportunity cost. From the single fact that the human is the bottleneck, the conclusion that opportunity cost dominates comes out automatically. That’s why I have the agent return quickly on a light setting and spin the human review-and-judgment loop as fast as I can. It isn’t a matter of taste. It’s the rational consequence of not stalling the bottleneck. When I Flip to a Heavy Setting Anyway I’ve been pushing the light setting this whole time, but that’s not to say lighter is always fine. The mistake shape “barely changing” holds for ordinary tasks, the kind where the bottleneck is human review. In the following situations I flip to a heavy setting without hesitation. - Genuinely hard design decisions: when the option space is wide and evaluating the trade-offs is itself the core of the work. Here, thickening the reasoning can actually improve the shape itself - Deep debugging and root-cause investigation: when the clues are thin and you can’t reach the true cause without following a long chain. Letting it think hard can land on the answer faster than a human tracing it by hand - Domains where human review is weak: when a human can’t quickly judge whether the output is correct. If review can’t catch it, more weight falls on the quality of the generation itself In short: light when review is the bottleneck, heavy when the model’s own thinking is the bottleneck. The axis of judgment stays consistent, deciding by which cost dominates. Keep the default at a light setting and raise it to a heavy one only when needed. This asymmetric default is, I think, the practical landing spot for minimizing opportunity cost. Conclusion Here is my current thinking on how to choose a coding-agent’s model setting, in three points. - The mistake shape barely changes with reasoning tokens: today’s high-intelligence models fail with similar shapes on light and heavy settings. The angles a human must catch in review are the same, and going heavy doesn’t let you skip review - So decide by opportunity cost, not token cost: what a heavy setting buys is a slight drop in frequency, a small payoff against the added wait. What bites is not the token cost visible as a dollar figure but the opportunity cost of a human’s hands being stopped - Opportunity cost dominates because humans are the bottleneck: since the ceiling on throughput is on the human side, stalling the bottleneck is the biggest loss. That the invisible opportunity cost is large follows self-evidently from this single fact However smart the tools get, what sets a day’s throughput is the human side. So I deliberately run smart models on light settings for speed, and I make not-stalling-my-own-hands the top priority. Not to skimp on the token bill, but to cut the opportunity cost that’s so hard to see. That’s all from working out that, since the mistake shape doesn’t change with reasoning tokens, you should pick your model by opportunity cost over token cost, from the Gemba.