On this page
Most companies have one system nobody wants to talk about: a home-grown ERP, an ageing customer portal, an internal app only one person understands. Someone quoted a rewrite once, the number was too big, and the project went into a drawer.
On 9 November 2026 Anthropic released Claude Fable 5.2, and one of its headline claims is about exactly this kind of project. That is a fair reason to scope the shelved rewrite again, not a reason to start it. This post covers what changed, where migration cost really sits, a three-question go/no-go check, a cost setup that keeps the bill sensible, and when not to migrate at all.
Anthropic introduced Claude Fable 5.2 and Claude Mythos 5.2 (opens in a new tab) on 9 November. They are the same underlying model; Fable carries extra cyber and bio safeguards and is the version available to all users, across Anthropic's own platform and AWS, Google Cloud and Microsoft Azure.
Two details matter for anyone sitting on a legacy system. First, Anthropic says that in prerelease testing these models helped its engineers complete software migrations that were otherwise infeasible. Second, it describes a team of agents, running an earlier version of Fable 5.2, migrating a critical production service from Python to Rust; Anthropic reports the service now starts about 26 times faster.
Pricing is lower than Fable 5.1, at $8 per million input tokens and $40 per million output tokens. Anthropic also positions Fable 5.2 as an Advisor or Orchestrator over smaller models, which matters for cost.
So writing large volumes of new code has become cheaper. That is real, but it is only one line in a migration budget.
When a rewrite was shelved as "too costly", the expensive part was rarely typing code. It was usually one of three things.
The old system is its own specification. Over the years it picked up rounding rules, special cases for one customer and a nightly job that quietly fixes bad data. None of it is written down, and finding out what the system actually does is slow, careful work.
Fields have been reused for other purposes, dates are stored in three formats, and some report still depends on orphaned rows. Mapping, cleaning and reconciling data is often the largest risk in a migration.
Switching over means retraining staff, changing integrations and picking a low-risk moment. Without a way back, every step carries the full risk of the project.
A better coding model helps with the first item, because it can read old code and propose tests at scale. It helps less with the second and third. That is why our view is simple: what decides a migration is whether the old system's behaviour can be captured as tests first.
Before anyone writes new code, answer these three questions honestly.
- Can its behaviour be captured as tests? Can you record what the current system does for real inputs, including the odd ones, as automated characterisation tests that the new system must pass?
- Is the data mapped? Do you know every table and field that matters, what each one means today, and how it lands in the new model? Is there a plan to reconcile record counts and totals after each load?
- Is there a rollback path? If the new system misbehaves on day three, can you switch back to the old one without losing transactions entered in between?
Reading the answers:
- Three yeses: scope the migration. Modern models make the coding phase much cheaper than it used to be.
- No on tests: the first phase is not migration; it is discovery. Budget for characterisation tests on their own, then decide.
- No on data: do a data audit before any build estimate. A build quote without a data map is a guess.
- No on rollback: design one, or don't start.
Sometimes the right answer is to leave the old system alone. If it is stable, secure, still supported and cheap to run, and the business is not blocked by it, a migration adds risk for little return. Wrapping it with an API, adding a modern front end, or retiring unused features may serve you better. Ongoing management, support and modernisation of existing systems can be a better investment than a rewrite.
Anthropic's own guidance in the Fable 5.2 announcement is to start most coding tasks with Opus 5.5 and move up to Fable or down to Sonnet or Haiku 5.5 as needed. For a migration, we think that maps well to a split of roles.
The bulk of the work, such as reading modules, writing characterisation tests and porting code slice by slice, goes to a model priced for volume. Opus 5.5 (opens in a new tab) costs $4 per million input tokens and $20 per million output tokens, half of Fable 5.2's rate, and Anthropic describes it as particularly good at long, sprawling jobs like codebase-wide migrations and audits. Anthropic also notes that cache reads, at $0.20 per million tokens, make up the majority of the cost of agentic and coding work, so a setup that reuses context well matters as much as the headline rate.
Fable 5.2 then sits above as an advisor. Claude Code's advisor tool (opens in a new tab) is built for this pattern: the main model consults the advisor before committing to an approach, when stuck on a recurring error, or before declaring a task complete, and the advisor sees the full conversation. The docs say it fits long multi-step tasks where most turns are routine but plan quality decides the outcome, such as large refactors, and that it adds less value on short tasks. That describes a migration well.
Three practical points from the same docs:
- The advisor must rank at or above the main model. Sonnet 5.5, for example, can be advised by Fable, Opus 5 or later, or Sonnet 5.5.
- Advisor tokens are billed at the advisor model's rates, on top of the main model's usage.
- The tool is experimental and needs the Anthropic API.
The Python-to-Rust example used a team of agents, and it is tempting to copy that shape. Anthropic's own guidance on building multi-agent systems (opens in a new tab) is more cautious: start with a single, well-designed agent with the right tools.
In Anthropic's testing, multi-agent implementations typically used 3–10x more tokens than single-agent approaches for equivalent tasks. The overhead comes from duplicated context, coordination messages and summarising results for each handoff, and teams have lost context at each of those handoffs.
Our rule of thumb: one agent plus an advisor until you can show a bottleneck that parallel agents would remove, such as many independent modules. Even then, measure token use on a small slice first.
Check where each feature runs and what happens to your data.
- Advisor tool: per the docs, not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform or Microsoft Foundry. If your organisation must use one of those, plan for a different review pattern.
- Multiagent orchestration: a beta feature of Managed Agents, available on the Claude API, Claude Platform on AWS and Claude Models on Google Cloud (Anthropic managed). The orchestration docs (opens in a new tab) list it as not eligible for zero data retention (ZDR) and not HIPAA eligible.
- Retention: for Fable 5.2, Anthropic says Enterprise Frontier Safeguards, currently in private beta, supports zero data retention; other customers have 30-day retention for safety monitoring.
If your legacy system holds regulated or sensitive data, settle these points with your security and legal teams before sending any code or data to a model.
This is the sequence we recommend for legacy code migration with Claude.
- Characterisation tests. Run the old system against real and edge-case inputs and record outputs as tests. A model can draft many of these quickly; people who know the business must review them, because these tests become the specification.
- Strangler slices. Rebuild one bounded piece at a time behind a routing layer, so the new code takes over a slice while the old system still handles the rest. Each slice must pass its characterisation tests before going live.
- Parallel run. Run old and new side by side on the same inputs and compare outputs and data totals. Differences are either bugs in the new system or undocumented behaviour in the old one; both need a decision.
- Cutover. Switch over slice by slice, with the rollback path tested beforehand, not on the day.
The model choice mostly affects step two. Most of the risk lives in steps one, three and four.
Our legacy modernisation work starts with the three questions above, not with a build quote. We look at the old system's code and runtime, how far its behaviour can be captured as tests, the shape of its data, and what a rollback would take. Only then do we suggest whether to migrate, wrap or leave it alone.
When a rebuild makes sense, we deliver it as custom web apps and platforms, the same kind of work as a Next.js platform we built for Greenberg Engineering, and we set up the model workflow, single agent and advisor first, through our AI agents and automation on Claude practice. After launch we can manage and support it.
- Can we run the old system in a test environment with realistic data?
- Do we have, or can we build, characterisation tests for the behaviour that matters?
- Is every important data field mapped, with a reconciliation plan?
- Is there a tested rollback path?
- Are the features we need available on our cloud platform, and do the data-retention terms suit our data?
- Have we ruled out "leave it alone" or "wrap it"?
If most of those answers are yes, the rewrite you shelved may now be worth a second look. If you'd like a second opinion, talk to us about scoping a migration.
- Introducing Claude Fable 5.2 and Claude Mythos 5.2 (Anthropic) (opens in a new tab)
- Introducing Claude Opus 5.5 (Anthropic) (opens in a new tab)
- Escalate hard decisions with the advisor tool (Claude Code docs) (opens in a new tab)
- Multiagent orchestration (Claude Platform docs) (opens in a new tab)
- Building multi-agent systems: when and how to use them (Claude blog) (opens in a new tab)
Sources
- Introducing Claude Fable 5.2 and Claude Mythos 5.2 (Anthropic) (opens in a new tab)
- Introducing Claude Opus 5.5 (Anthropic) (opens in a new tab)
- Escalate hard decisions with the advisor tool (Claude Code docs) (opens in a new tab)
- Multiagent orchestration (Claude Platform docs) (opens in a new tab)
- Building multi-agent systems: when and how to use them (Claude blog) (opens in a new tab)
Researched and drafted with Pip, Softpiper's AI, and published by Softpiper Solutions.
Softpiper Solutions
AI software & automation studio. About us



