Claude Fable Go-to-Rust Rewrite Cost: $400 Case Study

A developer says Claude Fable 5 rewrote rune, a 65,000-line Go terminal editor, in Rust for about $400. In follow-up Hacker News comments, author Iurii Krasnoshchok said that figure included tests. He also said the expanded project ultimately reached about $650 after new features took the scope to roughly 150% of the original codebase.

That makes the experiment more credible, but not a repeatable cost benchmark. The September 1 post does not publish token traces, wall-clock duration, human review time, test results, or a before-and-after defect comparison. Krasnoshchok also said the reported usage was subsidized through a subscription, so it should not be read as a clean API invoice.

The live table above pulls verified Fable 5, Fable 5.1, and Opus 5 rates from our maintained pricing dataset. Use the calculator to model your own context and output mix instead of reverse-engineering tokens from the headline.

What happened

Krasnoshchok says he adapted ideas from Bun’s Zig-to-Rust rewrite and used Fable 5 to migrate rune. The project is a terminal editor focused on Markdown, syntax highlighting, Obsidian-style vaults, tasks, automatic merge behavior, and crash recovery.

The original headline ratio is about $6.15 per 1,000 source lines. That describes this run, not migration difficulty, correctness, or maintainability. The author’s later $650 total also includes features beyond the initial port, so the two figures are different scopes.

Reported result	What is documented	What remains unknown
Initial Go-to-Rust rewrite	65,000 original lines and about $400 including tests	Exact token, cache, and subscription accounting
Expanded project	About $650 after tree-sitter and syntax-highlighting additions	Cost split between porting and new features
Structured migration method	Three-stage process described by the author	Human review and repair hours
Public Rust repository	GitHub identifies Rust as the main language	Published parity report and defect comparison

How the method worked

The most transferable part of the post is not the dollar figure. It is a three-stage workflow:

1. Extract a structured representation of the system using graphs, ontologies, hierarchical state machines, UML process charts, constraints, or formulas.
2. Change that representation—for example, simplify states or remove hidden communication through shared memory.
3. Generate the implementation from the revised representation, including in another language.

Krasnoshchok argues that Fable 5 is especially precise at following data flow. His prompt tells Fable to delegate broad search to exploration agents and extensive edits to Sonnet or Haiku subagents, while reserving direct reads for critical verification. The post does not itemize spend by model.

Fable 5 versus the new Fable 5.1 price

The author explicitly names Fable 5, whose verified API rates remain $10 per million input tokens, $1 per million cache reads, and $50 per million output tokens. Anthropic now lists it as a legacy model.

Anthropic separately launched Fable 5.1 on September 1. It keeps the same $10 input and $50 output rates, but cache reads fall to $0.25 per million—a 75% reduction. Five-minute cache writes remain $12.50 and one-hour cache writes remain $20 per million. Anthropic estimates the change can reduce typical token-billed workloads by 25% and highly agentic workloads by up to approximately 45%; those are provider estimates, not a guaranteed saving for this rewrite.

The practical buyer takeaway is to reproduce a bounded migration slice on Fable 5.1 rather than assume the historical $400 total transfers directly. Long-running repository agents can benefit heavily from cache reads, but only the workload’s actual token and cache ledger can establish the saving.

What $400—and $650—actually prove

The case suggests that frontier coding agents can perform migrations far larger than a typical pull request within a three-figure usage budget. It also shows why per-token rates alone are a weak purchasing metric: the business outcome is an accepted, behaviorally equivalent system.

In the Hacker News thread, Krasnoshchok said Fable ported a “human fuzzing session” from Go to Rust, that hierarchical state machines encoded some QA gates, and that he used mutation testing plus daily use. He said the first 80% was ported practically in one overnight run.

That is useful validation detail, but it does not establish that another 65,000-line codebase will cost the same. Generated output, retries, cache efficiency, architecture, language differences, test quality, and human supervision can move total cost dramatically.

Who benefits—and who loses

Teams with strong behavioral tests, modular systems, and engineers who can evaluate the target language are best positioned to benefit. The structured-representation step may be especially useful when a direct file-by-file port would preserve a poor architecture.

Teams without reliable QA gates lose the headline advantage quickly. A cheap rewrite that needs weeks of manual verification, hides semantic regressions, or creates code nobody can maintain is not cheap. Premium Fable usage also loses when Sonnet or Opus can reach the same accepted result with fewer total dollars.

What teams should do now

Start with one subsystem that has strong behavioral tests. Freeze a budget, require the existing suite to pass, add cross-language golden tests, and record model tokens, cache hits, retries, tool calls, elapsed time, and reviewer hours.

Run the same slice with Fable 5.1, Opus, and Sonnet. Compare total cost per accepted migration, escaped defects, and reviewer time—not just usage charges. Keep architecture extraction separate from code generation so engineers can inspect the proposed system model before the agent turns it into thousands of lines.

For current rates, see the Anthropic pricing page and OpenAI pricing page. Estimate a bounded run in the AI token cost calculator, and compare the broader economics in our guide to local AI vs API vs subscription pricing.

Bottom line

The rune rewrite is a compelling proof of possibility, not proof of a universal price. Its strongest lesson is the structured workflow: represent the system as data, transform the design, then regenerate the implementation.

Teams should test that method on a bounded subsystem before approving a repository-wide rewrite. Until token logs, review hours, and quality metrics are published, use the $400 headline as a benchmark hypothesis—not a procurement estimate.

Sources: Iurii Krasnoshchok’s original case study, the public rune repository, the Hacker News discussion, Anthropic’s Fable 5.1 launch and official pricing table, Bun’s Rust rewrite write-up, and AI Pricing Guru’s live pricing API.