Fable 5: The Complete Workflow Guide
Theo demonstrates how to maximize Fable 5's capabilities through strategic prompt design, cost optimization, and multi-model orchestration. By using high reasoning effort (not max), routing tasks to specialized models, and leveraging workflows and sub-agents, he shipped a month's worth of work in days while keeping costs around $150 across all models.
Why Fable 5 Is a Paradigm Shift
Fable isn't just smarter—it goes further
Fable 5 differs from previous models not merely in raw intelligence but in its ability to handle end-to-end implementations, testing, verification, and multi-step task decomposition with sub-agents. It can break work into smaller pieces and hand them off autonomously, enabling capabilities previous models couldn't approach.
Productivity jump on day one
On the first day of having Fable back after a period without it, Theo completed more work than in the entire month prior. The model shipped code, merged implementations, and fixed issues at a pace that fundamentally changed his workflow expectations.
Misconceptions about Fable being nerfed
Twitter claims that Fable is nerfed, too expensive, or worse than Opus are incorrect. The model is genuinely excellent; the issue is that using old Opus prompts on Fable won't unlock its true potential. It requires a fundamentally different approach.
Cost Optimization: The Critical First Step
Avoid X-High and Max reasoning effort
X-High and Max reasoning settings cause Fable to overthink each step, leading to overly complex solutions, excessive changes, and dramatically higher costs. High reasoning effort is smarter and more cost-effective because it balances depth with efficiency. Reasoning effort only applies per tool call, not to total task duration.
Real cost example: Month of work for $150
Theo completed a month's worth of stalled work (16 open PRs, multiple projects, 5.5 hours of continuous agent work) for approximately $150 total across Fable and other models. This was possible by staying within subscription limits and routing expensive tasks (logs, PDFs, computer use) to cheaper models like GPT-5.5.
Codex subscription is absurdly generous
The Codex subscription provides approximately 14,000 dollars per month of inference usage, which is extremely difficult to exhaust. Theo used only 15% of his weekly Codex limit while using it heavily for hours daily. This makes GPT-5.5 effectively free for token-heavy tasks like computer use, log analysis, and PDF reading.
Teaching Fable to Route Tasks: The Claude.md Strategy
Model glossary: Define intelligence and taste
Create a glossary in Claude.md that defines key terms like 'intelligence' (how hard a problem a model can handle unsupervised) and 'taste' (UI/UX, code quality, API design, copy). This helps Fable understand which model to use for which task without explicit instructions each time.
Set routing rules: Cost as tiebreaker only
Establish clear priorities in Claude.md: intelligence > taste > cost. Cost is only a tiebreaker when other factors are equal. Cheaper models should be used to gather information and test approaches before escalating to expensive models. This prevents mediocre work from shipping while keeping costs reasonable.
Teach Fable to shell out to GPT-5.5 via Codex
In Claude.md, explicitly tell Fable it can call GPT-5.5 through the Codex CLI using bash commands. For example: 'If computer use is helpful for completing or verifying work, shell out to GPT-5.5 with Codex for it.' This gives Fable access to 5.5's computer use capabilities without wasting Fable tokens.
Workflows vs. sub-agents: Know the difference
Sub-agents are spawned to perform individual tasks in parallel (e.g., five agents analyzing five files). Workflows are JavaScript programs that define multi-stage processes with dynamic queuing based on results (e.g., stage 1 triage, stage 2 conditional actions). Workflows excel at fan-out-and-verify patterns; sub-agents are better for parallel independent work.
Skills: Bridging Fable and Codex
Codex review skill for independent code review
Create a skill that allows Fable to request an independent code review from GPT-5.5 via the Codex CLI. The skill includes a workflow: identify review target, create artifact directory, run Codex review with focused prompt, read report, verify claims. This gives Fable a second opinion without burning Fable tokens.
Codex implementation skill for bounded work
Similar to the review skill, this allows Fable to delegate bounded implementation tasks to GPT-5.5 via Codex, typically on a work tree to isolate changes. The skill description must be detailed enough for Fable to decide whether to call it, but the full workflow details load only after invocation.
Computer use skill: Fable's secret weapon
A skill that invokes Codex CLI with GPT-5.5 for tasks requiring computer use, browser automation, simulators, screenshots, or app launching. This lets Fable leverage 5.5's superior computer use capabilities without building them into Fable itself. Trigger when user asks Fable to test flows, verify UI behavior, inspect running apps, or capture screenshots.
Skill descriptions are critical; commands must be exact
The skill description is what Fable reads first to decide whether to call it. Make descriptions detailed and clear. The command syntax must be exact because if Fable gets it wrong, it's annoying to debug. Test commands thoroughly and add them to the skill definition once verified.
The Lakebed Workflow: From Chaos to Shipped
Initial triage: Investigate 16 stalled PRs
Theo asked Fable to investigate 16 open PRs in Lakebed (a project with 50–80% complete work) and categorize them: ready to merge, need touch-ups, trumped by other work, or good ideas to scrap. Fable spawned a workflow with 16 investigators (one per PR) and a judge panel using Fable + Opus. Result: 14 of 16 unanimous, 2 contested but resolved.
Planning phase: HTML specs for each feature
After closing dead PRs, Fable created detailed HTML plans for remaining work, breaking each into sub-agents for planning and review. Plans included links to inspiring PRs, descriptions of existing implementations, and recommendations for next steps. Theo reviewed these on his phone and approved all five remaining feature streams.
Execution strategy: Orchestration over monolithic workflow
Rather than one giant workflow, Fable recommended orchestrating streams from the current session, spawning work trees for implementations, and using workflows only for multi-agent review before merge. This allows for human checkpoints (CI, review, merge) between PRs and accommodates mid-stream product decisions that a deterministic script cannot anticipate.
The goal: Merge with confidence
Theo set a goal for Fable to complete all planned work: rebase, branch, merge, close PRs, etc. He explicitly told it to merge to main after automated reviewers (BugBot, Microscope, Code Rabbit) approved. Fable ran for 5 hours, merging code continuously. Production deployments remained human-gated, so risk was limited to staging.
Verification and stress testing
After Fable merged all work to main, Theo personally stress-tested the staging environment, spun up other agents to try old and new features, and had agents review all changes between prod and main. Verification consumed more tokens than the original work but found no issues, indicating the work was solid.
Parallelizing Work: T3 Code and Remote Machines
T3 Code mobile app unlocks remote work
The T3 Code mobile app (open source, built by Julius) allows Theo to connect to remote machines via Tailscale and control Claude agents from his phone. This eliminated SSH friction (image pasting, scrolling, selection) and enabled him to spawn work trees and workflows from anywhere, even while at conferences.
Spinning up work trees on the fly
When Theo noticed small bugs or had ideas while on his phone, he could instantly spawn a work tree, ask Fable to fix it, and create a PR—all without touching his laptop. Example: adding a favicon to T3 Code's root level, committing, and creating a PR following repo guidelines took minutes.
Combining work trees to reduce PR clutter
Theo spawned five separate work trees on his phone for overlapping fixes. Rather than file five PRs, he asked Fable to access all work trees, pull changes into one branch, and handle conflicts. Fable completed this in 5 minutes, consolidating the work into a single testable branch.
Using execution time as an architecture signal
The time Fable takes to complete a task is a diagnostic: under 3 minutes suggests a simple fix (safe to merge), 15 minutes is concerning (pay attention), over an hour signals architectural problems. Example: mobile thread scroll jumping took 1.5 hours (scary), while a drawer behavior fix took 2 minutes 20 seconds (too simple, needs review).
Advanced Techniques and Mindset Shifts
Ask the model questions to align expectations
Rather than assuming Fable understands the plan, ask it clarifying questions: 'What streams of work do we need? Should we use one workflow or multiple work trees?' This alignment conversation prevents misunderstandings and often surfaces better approaches than Theo would have thought of alone.
Don't blindly copy workflows; learn and adapt
Theo deliberately did not share exact Claude.md or skill files because copy-pasting without understanding creates fear of breaking things. The goal is for users to learn the patterns, screenshot them, ask their model to help build similar systems, and then experiment and modify based on their needs.
Iterative refinement of Claude.md
Theo's Claude.md wasn't perfect on day one. As he ran into problems (timeouts, sub-agent confusion, cost overruns), he'd return to the thread, ask Claude how to prevent the issue, and add the solution to the file. This iterative approach turned a rough draft into a powerful orchestration tool.
Vibe proxy for multi-account load balancing
If worried about hitting usage limits, Vibe Proxy can auto-split traffic across multiple accounts. It uses the API key version of Claude Code (losing some features like slash remote control) but prevents bottlenecks. Theo set it up and found it pleasant to use.
Key Metrics and Results
PR volume: From stalled to shipped
Lakebed went from 16 stalled open PRs (50–80% complete, sitting for weeks) to all work completed and merged in 2–3 days. The project is now one month ahead of schedule after having fallen one month behind.
Subscription usage: Staying well within limits
Despite 5+ hours of continuous agent work and heavy daily usage, Theo's Claude Code subscription reached 40% usage and Codex only 15%. Neither subscription was stressed, proving that strategic model routing and high reasoning effort (not max) keeps costs reasonable.
Notable quotes
This model isn't a better Opus. The difference is how much further it can go. — Theo
Do not use Fable on higher than high reasoning efforts. X high and max are dangerous. — Theo
The sheer volume of work here, all 11 or 12 PRs merged not just in one day, but from one thread. — Theo
Action items
- Set Fable's reasoning effort to High (not X-High or Max) to reduce costs and improve output quality.
- Create a Claude.md glossary defining 'intelligence' and 'taste' for your use case, then establish routing rules (intelligence > taste > cost).
- Build a skill that teaches Fable to call GPT-5.5 via Codex for computer use, log analysis, and PDF reading tasks.
- Start with a simple triage workflow (investigate, categorize, judge) to organize stalled work before attempting large-scale execution.
- Use checkpoint-driven orchestration (session-level, work trees, workflows for review) instead of monolithic workflows for multi-PR projects.
- Set up T3 Code mobile app with Tailscale to spawn work trees and workflows from your phone.
- Iteratively refine your Claude.md and skills as you encounter problems; ask Fable how to prevent issues and add solutions to the file.
- Use execution time as an architecture diagnostic: under 3 min = safe, 15 min = caution, over 1 hour = investigate architecture.
- Ask Fable clarifying questions about the plan before execution to align expectations and surface better approaches.
- Consider Vibe Proxy if you're worried about hitting usage limits across multiple projects.