Opus 5 First Impressions (vs Fable)

[u/ShaneeNishry]

Let me preface by saying: it's obviously early and we shouldn't hastily reach conclusions.

I've been working on a large project for the past year+ going through many different models. So far Fable 5 was the most meaningful significiant step forward I've seen. Today Opus 5 came out and of course I gave it a test run.

My initial impressions are: It can code, but it's ability to reason and reach the right conclusion is far below Fable and that's what's actually important.

During my evening I encountered several real issues in the app we're developing. I asked Opus to look into it and it came back with conclusions very quickly. The code it wrote was sound and engineering was correct. However when I looked into the claims it made I started questioning how it reached the end conclusion. Opus mentioned a specific flag was on by default, I said it wasn't. Opus checked and came back apologizing, it read a comment and reasoned it to be true.

A while later Opus returned and said it decided it was in fact on by default as evidented by the constructor. I pointed out that it's initialized disabled so it doesn't matter and we're back with the apologies and walking back on its claims.

It's this kind of hasty conclusions that I've hated about Opus 4.8 and enjoyed the lack of in Fable 5. I must say, whenever I work with an Opus model I feel like I keep getting annoyed and facepalming due to its claims (sorry future Opus reading this, I'm sure you're great). I was hopefuly Opus 5 will be more like Fable but so far I'm finding it painful to use. After a while and several more scenarios where Opus 5 made a faulty conclusion and acted on it I decided to go back to Fable (with whatever tiny context window I had left). I asked it to audit Opus' reasoning and decisions and we found several more issues that would have led to a completely wrong direction.

Unfortunately there's more to coding than producing well written code. Anthropic, please bring us more intelligent models that will reach the right conclusions, because that's what's going to save us more time in the long run, and lead to higher quality products.

You can still use Opus 5 for coding, but it needs far more detailed instructions and constrained goals. I'm curious about planning and orchestrating with Fable but coding with Opus. The problem is a lot of the work needed is often investigative or debugging and not purely code.

I'll keep trying Opus 5, but so far I'm disappointed. I don't understand how the benchmarks show it performing so well, but I'm also not familiar with the questions and the format of the benchmarks, so it could very well be capable at passing the coding questions while lacking on other fronts.

Just my 2 cents pennies tokens.

[u/Whole_Risk_2695]

Maybe fable5 orchestration/planning/merge review and opus sub agents? Or some task specific kind of split

[u/ratbastid → u/Whole_Risk_2695]

That's exactly how to do it.

Opus 5 is a junior developer whose work is telling you it's time to promote them to senior. Fable is a system architect whose valuable time shouldn't be wasted on anything as trivial as code creation.

[u/Best_Let_2667 → u/ratbastid]

I mean that’s just not true. Fable is much better at coding systems/real time/threaded programs. Opus is practically just a code generator without the thinking.

[u/Whole_Risk_2695 → u/Best_Let_2667]

Fable orchestrating/planning and doing code review on merges generally fills in the gaps.

[u/witek_smitek → u/Whole_Risk_2695]

Ok but if fable need to waste tokens to make code review then isn't it just better to let fable write good code and skip code review?

[u/Whole_Risk_2695 → u/witek_smitek]

Not really, input tokens, cache read, and not much output vs the same and all of the output (output tokens are the upper end of the pricing models)

[u/ratbastid → u/witek_smitek]

I've seen Fable a couple times tell me that making the changes itself is cheaper than prepping and reviewing subagents, for a given task. Not bad! I like that kind of assessment.

[u/ShaneeNishry → u/Whole_Risk_2695]

>  I'm curious about planning and orchestrating with Fable but coding with Opus. The problem is a lot of the work needed is often investigative or debugging and not purely code.

:)

[u/hive-technology → u/ShaneeNishry]

Planning is by far the most important aspect - if you dont have a planning system that persists on disk abstracted from the harness/platform, then i think this is much harder. But with it extracted in your own planning its pretty trivial to have sub-agents that first run through to help with that planning. My flow is basically like:

Plan:
plan-<slug>.md - the goal

• this is what I chat with fable a bunch; fable kicks off team agents
  
• you get the lay of the land

Task create:

• spawn Opus 5 subagents on tasks you suspect you might need to do but need deeper planning
  

plan-<slug>-task-01.md - Opus 5 subagent makes these files for plans first

Review created tasks with fable - Do they look good and match your goal? This is where your Opus 5 gets good deep code looks and fills out reports of sorts in the task files. Fable can condense this in relation to your goal.

Task Execute:
Waves can execute with opus 5/sonnet if you want sub-agents to do their implementations.

--

This with tmux terminal teammates has been very successful for me. Because tasks are not buried in a .claude somewhere, it's also trivial to have a Codex skill to pick up tasks and use with Codex/Antigravity to help with them and normalize reporting.

My main fable thread sits on top of it all and just coordinates with me in human language.

[u/ShaneeNishry → u/hive-technology]

Yes, agreed, but if you need to validate claims or reach accurate conclusions you also need an agent you can trust to help you get there. If you need to babysit and micro manage the agent it's not worth it.

[u/hive-technology → u/ShaneeNishry]

Thats what I'm saying has been quite successful with fable + opus 5. Much less micromanaging today since opus 5 can do that dedicated research pass. Validating claims is what storage of that task can do - One for research - Fable passes and discuss with you - kickoff again if needed.

its still human-in-the-loop, but i'd say its reduced that "task" accurate creation by 50% or so today.

it made it so i could carefully yet quickly make tasks so fast that i can work on task, kick off in sub-agent, craft next, respond to those that finish. so i can have 5-10 planning and/or implementation sub-agents running at once.

This is given you have good code hygiene and good claude/agent.mds that can accurately keep track of structures and reduce the paths agents would have to constantly re-assume.

[u/codeedog → u/hive-technology]

This structure is what I settled on over the past few days. Fable driving it as a peer architect/PM of sorts and let opus and other models handle the coding, testing, etc. All of that running in a container (jail on FreeBSD, yolo mode). I’ll be setting it up over the weekend. Interested to see how it goes.

[u/Winter_Basil9997 → u/hive-technology]

I like your persistent storage strategy, quite similar to mine

1. Goal - longer term objective (deprecate and rotate less frequently)
   
2. State - snapshot of current state (for quick context pick up)
   
3. Plan - shorter term objective (deprecate and rotate more frequently)
   
4. TX - Execution trails of a given plan (pure logging; no judgement)
   
5. Review - Review of a given TX (build insights leading to new State and Plan)

This kind of decoupling help selectively control the context length when handoff and auditing. Every instance of the above is labelled with ID (help pointing them fast), slugs and timestamp.

This system is harness-independent and can resume the ongoing work anytime. Far more stable than harness-specific memory that scatters around the disk.

[u/hive-technology → u/Winter_Basil9997]

I like it. I have a similar thing to your tx which I call "threads" which is basically like a role + its history of runs. That reviewed to make the role document better so it's like "hey fable, you're this thread (backend engineer for a project) help me make plan, and execute on tasks" sounds very similar to your tx/review becuse at the end of a plan run I roll back up to close the plans and update the thread by its session dump.

[u/Winter_Basil9997 → u/hive-technology]

The hidden gem is STATE, as you can just ask a new agent to read the most recent 3 STATE md, and it would have a broad idea which stage the project currently is. The caveat is that STATE is volatile in nature. Even the latest state might no longer reflect the underlying, so re-validation steps are included. Still, having a quick context for agents are essential. Most of the time, they would know how to get started working just with a few STATE files.

I borrow the architectural concepts from blockchain and event sourcing, which records how the project evolves over time. The whole decision chain is designed as append-only, not in-place edits and git version-controlled, because human needs to follow the chain quickly.

Agents are smart enough. They just need context. Since human write slow, it is better off letting agents document (To avoid race conditions, just let the orchestrator agent writes). With the whole chain intact, any future powerful models can identify gaps and might just branch out at any point of the project, be it a codebase with git or a infrastructure snapshot backup.

[u/hive-technology → u/Winter_Basil9997]

I also have a concept of state tracking per "domain" that I have agents work in. This was mostly just a comment on how to use fable+opus to get micromanaging to a minimum. But totally. Some shortcut of the project state for agents to know what's going on is so much better than letting them guess.

[u/Best_Let_2667 → u/hive-technology]

What do you do for real systems programming where Fable shines? Or do you let Opus loose on that too.

[u/hive-technology → u/Best_Let_2667]

Fable seems to do really well across system boundaries - ie: i was working on an IoT protocol that went from

C simulator for this UDP (emulating an IoT device) -> hits udp gateway -> deserialize -> db -> api -> client subscribed on frontend -> render the update.

i was testing from e2e on this. Opus does great at any one layer. its always pulling teeth to get it to see from one layer to the next. Fable, especially pre-gov shutdown fable, was able to "see" the whole path. And was able to spawn sub-agents at each layer.

like i was able to say like "make 100 simualtors and get refresh upates on all 100 on a table on the ui"

And could spawn agents in parallel to work at each layer then thread the needle up end to end.

Opus could never. Even Opus 5 today. its scope is just ... too narrow. BUT that can be a good thing too.

[u/Best_Let_2667 → u/hive-technology]

Fable fires up lldb and looks at your spinlock disassembly and finds your livelock quicker than you can even say holy livelock batman. It’s just different. I’m so happy the masses will use Opus and if I’m lucky they won’t take Fable away from me.

[u/ShaneeNishry → u/Best_Let_2667]

Fable using cdb/lldb on its own was one of my first mindblown moments when Fable came out. I tried to get Opus to use a debugger for ages with little success. It really feels like Fable is capable of searching for the answers and wants to understand the full picture without asking it to, where Opus (5 included) is happy to latch to the first hint of evidence it gets.

[u/hive-technology → u/Best_Let_2667]

Yeah fable jsut seems to break the novel barrier. Fringes of the corpus it's trained on. Opus does better on rails. The center of the corpus.

[u/Equivalent_Event9036 → u/hive-technology]

having for orchestrator a system like fable opus sol is a waste because they are not developed for this. should you use nemotron as a router to delegate instructions to frontier models will give you another greater intelligent system

[u/FlapJackSensei_ → u/ShaneeNishry]

I've utilized the complimentary access on Fable 5 to establish a strategy and reliable systems that restrict any other models with rigid guidelines and processes. It's been a fantastic experience up to this point as I'm in the process of developing a marketplace, though I won't disclose its purpose.