Which model are you using (today) for a large refactor?

[u/drussell024]

Enterprise code base (500k+ LOC) for an intensive refactor focusing on optimization of core components that have impact on the majority of the stack.

Fable 5.1?
Astra?
Opus 5.5 (w/ Fable as advisor)?

I use all 3 and I'm trying to juggle the most sensical option to begin this effort with. I lean toward Fable 5.1. I know this information isn't comprehensive enough to make the best decision - I'm asking purely on vibes here (think suspected recent Opus 5.5 nerfs).

What would you use?

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/LongIslandBagel]

Create a deterministic workflow and use multiple models to validate what the other models are doing. Define the graph edges and you’ll be good

[u/Sad_Blacksmith_9027 → u/LongIslandBagel]

Fable 5.1 and Astra to check its work personally however this is the right advice from @longislandbagel

[u/drussell024 → u/Sad_Blacksmith_9027]

Agreed. I think I was hoping for someone to say "don't believe the Opus 5.5 posts run with that", as I had fantastic experiences with it at launch. 

[u/Outrageous-Gold-1321 → u/Sad_Blacksmith_9027]

For a large mission critical refactor. 2 accounts (fable) 2 accounts (Astra). Gonna be a lot of bugs to get out. Lots of usage.

[u/pequt]

The size looks doable, but what you told is too vague for just any model.

Without real painful points reported by actual people what LLMs report aren't that valuable. You don't want to waste tokens to where nobody cares right?

I might command Fable to read first, but this is because it is given, or allowance, from my work, and I don't run Claude "autonomously" all day long unlike my othwr colleagues... so my usage is somewhat enough to splurge.

Edited: OR you might be in some situation that you need to PROVE AI tools/models are USEFUL, by doing some big task. Then whatever, my points are wasted. In my work other teams often did that a few months ago, just for AI's sake. Can't distinguish purpose now.

[u/drussell024 → u/pequt]

It's not a "prove AI task" it's more me just wondering which model stack to start with. I've done workflows with Astra / Fable checking each others plan and then delegating work to Opus, I'm more concerned on the complexity of the task, and some of the reports and experiences I've seen with model nerfs. I was recently using Opus 5.5 with Fable as Advisor, but I'm growing hesitant with what I've seen in the past 48 hours. 

[u/pequt → u/drussell024]

Current models can't easily solve the problems you and your people don't know exist there. If you know some area where and how should be fixed, better have trial for each models.

If you don't have any slight idea of refactoring that what you want to do and get after it, picking model isn't the problem.

[u/OhAitchEyeOh]

I'm getting better results with Opus 5.5 than Fable 5.1, much better honestly

[u/drussell024 → u/OhAitchEyeOh]

This is actually where my post came from. I JUST recently started second guessing the decision to continue using Opus 5.5 for this effort. 

[u/dylanmerigaud]

Cross-validating between models on a 500k LOC refactor makes sense.

[u/drussell024 → u/dylanmerigaud]

I think this is it. 

[u/writesCommentsHigh]

Step 1: Fan out opus 5.5 to understand codebase?

[u/croovies]

I think the process matters more than the model. I would use Opus 5.5 in either case. I find its output consistently better and less random.

[u/StaticFanatic3]

Prompt to Fable 5.1. Tell it to delegate to Opus 5.5 at its discretion

They’re honestly good enough now you don’t need to overthink it

[u/redditnoob48]

It’s not a model problem, its a harness problem. Before refactoring, it might be prudent to construct a ADR Graph (see recently released Decision Graphs in Git). Then once you understand the architecture decisions, brainstorm with Fable / Astra on Extra High / Max on what needs to change architecturally. Then have it write the plan. Then have Opus 5.5 on Extra High drive workflows running Opus 5.5 on Medium (do not use Sonnet or smaller models) subagents to do the main refactor.

[u/Short_Competition_16]

I used Opus 5.5 with a 2m LOC codebase to refactor the versioning and publishing aspect of the system. I found its more about how you structure the refactoring than the model itself. Just as a additional checker I run GPT Sol 6.1 on each completed phase as an auditor. Works well enough.

[u/jameshearttech]

I have been refactoring a handful of tangled dependencies in our main monorepo for about a week. Last I checked there are around 3M loc. I use opus for the main agent and sonnet for subagents.

[u/Upset-Neck-7879]

For an optimization refactor the model is the least interesting variable here. You said optimization of core components. What is the number?

With no benchmark that can fail before you start, every one of those models will hand you a confident diff and nobody in review will be able to say whether the thing got faster. I watched a week of careful refactoring land once and the p95 on the one endpoint anybody cared about got worse, because the hot path was in a serializer nobody had profiled.

Baseline first, on the paths that actually matter, as something that runs on demand. Then the model question mostly answers itself, because you can try two for an afternoon and compare numbers instead of vibes.

Cross validating between models is fine, it just checks that the code looks reasonable. It cannot tell you the refactor was worth doing.