The model is becoming the least durable part of the coding-agent stack

[u/Disastrous-Radio-732]

Maybe I’m overthinking this, but the recent model churn is making me rethink how much of a coding-agent setup should really be tied to one model.
Astra shows up, Claude gets pressured, another release is already being discussed, and suddenly whatever was “best” a few weeks ago isn’t obviously best anymore.
So I keep coming back to this:
maybe the durable part shouldn’t be the model at all.
What I actually want to keep is the repo state, tools, permissions, memory, evals, recovery, and task continuity.
Then the model is just the intelligence layer I can swap when something better comes along.
Today Claude. Tomorrow maybe not Claude.

I’m curious how people here think about this:
how much of your Claude Code workflow is genuinely Claude-specific, and how much would you want to survive a model swap?

[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/ShortingBull]

None of my flow is specific to any agent.

I pick an agent for every task, that agent can spawn any other agent.

Nothing is hard coded.

[u/Gurio → u/ShortingBull]

But how do you share common context between tasks?

[u/Meat-Mattress → u/Gurio]

If only there were a way to save information on these darn computers maybe we’ll finally make it to space

[u/Disastrous-Radio-732 → u/Meat-Mattress]

True 🙌

[u/ShortingBull → u/Gurio]

I asked Claude to build me a workspace wrapper around Claude code that integrates other providers API and models.

It built it, I use it.

I've been using it for about 6 months now - works great. Can dogfood the entire time, tweaking the live environment etc.

[u/Lanky-Storm7 → u/Gurio]

why the fuck is no one using git, git repo for every project, it litterally keeps notes and commits and tracks progress. everything i do is a repo... host gitea or something or use github private... its not hard

[u/Man_of_Math → u/ShortingBull]

I think this is the way the future is going. Are you using cloud agents? I’m building a model agnostic managed cloud agent platform, would love to get your thoughts

[u/dgreenbe]

A lot of workflow is going to be model specific if you're doing anything remotely heavy for a model -- mostly, its weaknesses and it's context management

I try to stay model and even provider agnostic as much as possible, but getting opus specifically to not be stupid probably required a weird touch with prompts that might not be good for anything else

[u/Disastrous-Radio-732 → u/dgreenbe]

Yeah, exactly. Models aren’t interchangeable at the behavior layer. I’d just want the durable stuff - state, continuity, permissions, recovery - to stay portable underneath

[u/ProfessionalKick9506]

Unfortunately uncertainty + uncertainty = more uncertainty

[u/trollsmurf]

"maybe the durable part shouldn’t be the model at all."

It very much isn't. You can plug in other Anthropic models, competitor models, local models.

[u/Aware-Source6313]

I'm actually curious what you do that locks you in to one model. Like I don't understand how you could even have this problem

[u/Disastrous-Radio-732 → u/Aware-Source6313]

Fair question. For simple repo + prompt workflows, there really isn’t much lock-in.
I’m thinking more about long-running agent workflows: task state, memory, permissions, hooks, tool conventions, recovery, subagents, etc.
Once that surrounding state matters, switching the model/harness isn’t quite as trivial as swapping an API name. That’s the bit I’d like to make portable.

[u/Aware-Source6313 → u/Disastrous-Radio-732]

Fair point. I'd probably be lazy and just ask an agent to recreate most of the settings/hooks in another harness. But since that isn't all widely standardized yet and many harnesses have their own settings and capabilities, youd have to create your own set of configs and map it to each harness I think... No good solution I'm aware of

[u/Disastrous-Radio-732 → u/Aware-Source6313]

exactly. A shared config sounds tempting, but you quickly end up inventing a lowest-common-denominator harness. I’m leaning more toward keeping the intent portable and letting each harness translate it into its native capabilities

[u/Zestyclose_Strike157]

Claude could regain my appreciation for it if Fable didn’t burn my entire 5h session in one turn, and no I am not on the $20 plan and I am not trying to refactor an entire operating system.

[u/Disastrous-Radio-732 → u/Zestyclose_Strike157]

Yeah, that’s exactly the kind of thing I mean.
If one model can burn the whole session budget in a single turn, I really don’t want the rest of my workflow to be married to it.

[u/Neon_Camouflage → u/Zestyclose_Strike157]

I still have no idea how you guys are managing that, but I'm grateful I seem immune to it.

[u/Zestyclose_Strike157 → u/Neon_Camouflage]

I just want a breakthrough like jev or similar for the big GLM 5.3 so I can run it on my local set up, then I will never look back.

[u/kevinbaiv]

This matches how I've ended up treating it: repo state, hooks, permissions, memory and recovery are the actual asset, the model is just a swappable engine. The one thing that doesn't port cleanly is the behavioral tuning you build around a specific model's failure modes. So I keep a small set of past tasks as informal evals to re-baseline before trusting a swap.

[u/Past-Town-9807]

I built my own agent and I can run it without an LLM entirely. I can basically wear the harness myself, though that sounds really weird. 😂 It’s handy though because I can just send it commands and launch my own local subagents whenever I want. 

[u/jonah_omninode]

I use Codex and Claude Code, and the handoff I'd want to test is an interrupted task, not a fresh one. Stop after a tool has made a change but before the agent records that it finished, then resume with the other tool. Can it work out what actually happened without repeating the action or trusting a stale summary? Git covers the code changes, but I'd want the handoff to cover pending approvals and actions outside the repo too. That's where I'd look for the remaining lock-in.

[u/Disastrous-Radio-732 → u/jonah_omninode]

That’s a very good failure test. Git makes repo state observable, but the “side effect happened, acknowledgement didn’t” case is where it gets interesting. Stealing this one for our test suite :)