was released around a month ago and then, after three days, was pulled from the public because of security concerns. However, it’s now been returned to the Claude subscription, and anyone with the Claude subscription can access Claude Fable 5.
Unfortunately, Anthropic limited the amount of usage you get with Claude Fable 5 before hitting usage limits, limiting it to 50% of your weekly limits. Thus, you can’t just run Claude Fable on all of your tasks, because you’ll quickly hit usage limits and not be able to use it anymore
In this article, I’ll cover how you can get the most out of Claude Fable 5, still highlighting how you can use it to plan, schedule, and review code instead of having it perform the grunt work of implementing specific code.
I’ll discuss how you can get Fable-level intelligence but still stay within Fable limits. These are the techniques that I use on a daily basis to get the most out of my Claude Code subscription.
Why use Claude Fable 5
The main reason you should be using Claude Fable 5 is simply that it is the most powerful coding model out there at the moment.
I’ve tried basically all the major labs’ coding models, including:
- Google Gemini
- GLM 5.2
- OpenAI Codex
OpenAI Codex is by far the biggest competitor, and I would say that their models are very much comparable to Anthropic’s second-best model, Claude Opus 4.8. I would argue that in many cases GPT-5.5 and definitely GPT-5.6 are now better than Claude Opus 4.8, but they’re not better than Claude Fable.
There are a few things I would highlight that Claude Fable is just better at than any other model:
- Detecting issues in code
- Finding refactoring opportunities and improving separation of concerns, don’t repeat yourself, and other coding principles.
- Planning by looking into a repo, launching research agents, and making a good plan for how to implement a feature successfully
These are things that Claude Fable is just superior at. However, you should notice that I did not specifically mention implementation of code ’cause I do believe that Claude Fable is not that much superior on code implementations compared to Claude Opus 4.8, for example, which is what I’ll cover in the next section
How to maximize Claude Fable 5
My coding pipeline
The main way to get the most out of Claude Fable 5 without spending all of your usage limits is to not use Fable for pure code implementations, but basically use it for everything else.
On a high level, my coding pipeline works like this:
- Use Fable to plan an implementation or bug fix
- Use Claude Opus 4.8 or GPT-5.6 to implement the code
- Use GPT-5.6 to review the code
- Merge the code to dev
The good thing about this is that you’re only using Fable to plan, which is also the area where the biggest separation between Fable and other models is.
You’re thus not spending Fable tokens to implement code, which Claude Opus 4.8 or GPT-5.6 is essentially equally good at. This saves a lot of usage limits on Claude Fable, which you can use to plan a lot more tasks.
In some situations, you can also use Claude Fable to review code. However, in my experience, Codex is good enough at reviewing code itself, so you don’t need to use Fable on it.
Furthermore, Claude Opus 4.8 is my main driver for implementing code, and I thus like to use a separate model to review the code, which makes Codex the best alternative.
How to plan effectively with Claude Fable
In my last section, I covered my high-level coding pipeline to not waste tokens on Claude Fable when it’s not necessary, and you can complete the same work with Claude Opus 4.8.
However, another skill that you need is how to plan effectively with Claude Fable. How do you discover and make a clear plan that other agents can implement? How do you look for refactoring opportunities? How do you tell it to find bugs and make sure it has all the tools accessible, and so on?
The main point I wanna get here, compared to previous models, is that you should make Claude Fable work even more autonomously than you think.
You can even start tasks that you’re not even sure how to implement and what it could look like. Start discussing with Claude Fable and have it come up with the best solutions.
Usually what I do is that I describe a situation to Claude Fable. For example, I want to implement a certain feature. I then have Claude Fable research the repository I’m currently in. Come up with some different ideas on architecture and logic for how the implementation could look, and present the results to me in HTML. If it helps to use visuals for it. I tell Claude Fable to use as many visuals as possible for the implementation.
Notice, however, that I’m asking Claude Fable to make that decision on whether visuals would help or not, and it should make all the decisions on how to present it as simply as possible for me. I tried to instruct the model as little as possible, other than highlighting the task I want and how to verify the task is implemented correctly.
The thing that Claude Fable is incredibly good at is everything in between. So you provide a task, what needs to be done, how to verify that it is done, and Claude Fable can complete all the work in the middle, or at least make a plan on how to complete all the work, which you can use a model like Claude Opus 4.8 to actually implement it.
How to refactor with Claude Fable
Refactoring is becoming more and more relevant, and now that we have a lot of coding agents implementing almost all of the code.
I’ve discussed the topic of refactoring a lot in my previous articles, which can basically be summarized into the following:
When code implementations start taking longer than expected or more bugs than previously are being introduced, it’s usually a sign that the code needs refactoring.
Thus, you should always be on the lookout for when things start to take longer than they should, which is a clear sign that you should start refactoring the code. Furthermore, I don’t think the fact that you have to refactor the code means that you did something wrong previously. It’s just a natural evolution of working with coding agents. Once you’ve implemented enough new code, you basically always have to refactor it. And luckily, refactoring can simply be done with coding agents as well, so it doesn’t take that much effort and isn’t that cognitively demanding for you.
To refactor, you can give a prompt such as:
Look for refactoring opportunities in this repository, what should be
improved, look for bad coding practices, don't repeat yourself, poor
separation of concerns and so onAnd this will definitely work. If you haven’t refactored before, you should definitely just run this prompt right away and have Claude implement all of the recommended actions. However, there is a better way to refactor code with Claude Fable.
Basically, you as a human should discover the symptoms yourself by, for example, noticing that the code implementation in a specific area is taking longer than expected
Once you discover this, you note down which area of the code this happened in, and you point Claude specifically to this area. You can, for example, say:
The last time we implemented code in the processing pipeline, it took a
lot longer than expected and I think this is a sign that we need to
improve the code quality in that area. Research the coding session I ran
there and look for refactoring opportunities so that we can increase speed
and reduce bugs in the futureThis is particularly effective for two main reasons.
- You point Claude Code to a specific area where you know there are issues
- You give Claude Code logs from your coding agent where you can see what happened and why it took so long, giving it a better understanding of what needs refactoring.
You then run this prompt, tell Claude Code to provide the results to you in HTML, in a prioritized order, and then tell Claude Code to implement all of the improvements.
Conclusion
In this article, I covered how to get the most out of Claude Fable 5. Unfortunately, we have quite limited usage limits, and with the Claude Fable model, you just have to use it effectively. In short, I use Claude Fable for planning and then use models like Claude Opus 4.8 or GPT-5.6 to actually implement the code, saving a lot of token usage with Fable. In my opinion, this does not have a big impact on code quality because usually implementing the code is easier than planning what to do, and the differences between Fable and other models are smallest when it comes to actual code implementations. I believe we’ll see this more and more in the future, where you have some incredibly powerful models that are in limited supply, which you have to use with caution because of cost or limits. You just have to think about how you can use them as effectively as possible without spending all of the usage or racking up too many costs.
👉 My free eBook and Webinar:
🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)
📚 Get my free Vision Language Models ebook
💻 My webinar on Vision Language Models
👉 Find me on socials:
💌 Substack