Fable May Not Be the Best Choice for Some Engineers

Fable and Opus may not be the most comfortable tools for engineers who learned to code by hand.

I started thinking about this after reading Simon Willison's recent note. His point is simple: with a strong coding agent like Fable, it may be better to let the model exercise its own judgment than to spell out every condition yourself. Instead of writing detailed rules like "run tests for larger features, but not for small copy changes, except for design changes...," you can simply say: write and run tests where appropriate.

The same applies to cost. Rather than deciding manually which tasks should go to which model, you can ask the agent to choose an appropriate lower-cost model and delegate the work to a subagent.

Manual cars and automatics

This is a rough analogy, but it feels similar to driving a car. People who enjoy driving often like manual cars. They want to choose the gear themselves. They want to feel the engine speed and have the car respond directly to their intent. For people who simply want to get somewhere, an automatic is easier.

Software engineers are similar. If you have written code professionally for a long time, you usually have your own way of working. You may want to get the types right first. You may prefer small diffs. You may have a specific sense for how granular tests should be. You may even have an order in which you like to read an unfamiliar codebase. (At least, I hope you do.) For someone with that kind of style, a highly autonomous model like Fable or Opus can feel a little too automatic.

The stronger the model, the more small instructions get in the way

This is the same structure as management in human organizations. A junior member needs concrete instructions: read this document from this angle and summarize it in this format. A senior member can take a rougher assignment: I want to solve this problem, so investigate it, come up with an implementation plan, and move it forward.

Of course this does not mean throwing work over the wall. You still give the goal, constraints, and success conditions. You just don't dictate every step along the way. I think instructions for Fable and Opus are moving closer to the second case.

Choose coding agents by delegation level, not just capability

The tricky part is that the strongest model is not always the best choice. Choose your model by delegation level, not by intelligence. If you already have a strong preference for how development should proceed, steering a mid-tier model like Sonnet yourself may feel better than handing the whole process to a fully autonomous flagship model.

• If you want to decide the development process yourself, use a mid-tier model like Sonnet as a tool you steer closely.
• If you want to delegate the implementation approach itself, use a highly autonomous model like Opus or Fable.
• If your own development style is not fixed yet, it may be easier to delegate broadly to a flagship model.
• For maintenance work or small fixes in an existing codebase, a short interaction with a mid-tier model is often more efficient.

The value of Fable and Opus is not only that they write code faster. It is that you can delegate the way development proceeds. This is also why it pairs well with what people call vibe coding.

By vibe coding, I do not mean throwing vague prompts at a model and hoping for the best. I mean giving the model a goal like "I roughly want this kind of thing" and letting it handle larger decisions: task decomposition, how far to investigate, whether tests should be written, whether to delegate to subagents, and whether the final result is coherent. If you want to make those decisions yourself, the model does not need to be that autonomous.

To be fair, sometimes the automatic wins

Don't get me wrong: even if you love steering, there are moments when Fable or Opus is simply the right tool.

• Large refactorings across an unfamiliar codebase.
• Exploratory work where you don't yet have an opinion about the approach.
• Prototypes you might throw away tomorrow.

The argument isn't "manual is better." It's that delegation level is a choice - and if you always default to the most autonomous model, you're skipping that choice without thinking about it.

Manual or automatic?

Flagship models like Fable and Opus are not always the best partners for engineers who came up in the handwritten-code era. If you have your own style and want to keep your hands on the steering wheel, using a mid-tier model like Sonnet as an extension of your hands may feel better. If you want to delegate the development process itself, Fable and Opus start to show their real value.

In short: choose your model by delegation level, not by intelligence. For someone who likes manual cars, even the best automatic car is not always the most fun. But if the goal is simply to arrive, automatic wins. Fable and Opus are probably that kind of tool.

How do you choose your coding agent - by intelligence, or by how much you want to delegate? And if you learned to code by hand: are you actually comfortable handing the whole process over?

Note: This article was originally written in Japanese and translated into English with GPT.