How to Make Money With Claude Fable 5 (Full Guide)

For two years everyone used AI in one identical way

You enter a query, it returns a reply, you read it, you enter the next query

You are the motor. The AI only shifts when you push it

That entire way of working quietly ended, and most people haven't caught on yet

Last month an engineer gave Claude's latest model a tough problem and stepped away

It didn't merely reply

It ran for an entire day - fixed the original issue, then discovered four distinct flaws in the code beneath it, resolved those as well, and produced nearly a whole software update by itself

The developer didn't sit around prompting it move by move

They simply handed it one goal and came back to finished work

Fable 5 can operate all on its own for hours, occasionally days

https://x.com/claudeai/status/2064394146916229443

It designs a plan, does the work, tracks its own progress toward the goal, and corrects its own errors as it moves along without needing your following message

So the ability that matters most now isn't crafting a smart prompt

It's about learning to pass along an entire project and trusting it to complete it

Let me walk you through how, with an actual setup you can copy

Why "one reply at a time" was slowing you down

Consider how you currently work together with AI today

You request a function. You copy in the error. You request a fix. You copy in the next error. You request that it add tests

Twenty messages down the line you have something that mostly runs

Each of those twenty messages required your input. You were the glue keeping the project together. The AI was clever, but its attention span matched that of a goldfish

That wasn't a flaw on your end. It was a limitation of the model. Earlier models truly couldn't keep a long, tangled job in mind while steering it toward completion. So they were designed to handle one tiny step and then halt

Fable 5 is the first broadly accessible model designed the opposite way. It keeps the goal in mind, pursues it across a long stretch, and returns only once it's genuinely finished or truly stuck

The official messaging even claims that the longer and tougher the task, the wider its advantage over earlier models grows. That one shift changes how you're meant to use it

You stop being the motor. You become the manager

The single mindset change: hand it a goal, not a step

Here's the entire trick in a single line:

Describe the finished outcome and how you'll recognize it's complete, then step out of the way

A prompt informs the AI of its next move

A project shows it what "finished" looks like and lets it work out the steps

Weak (the former method):

1write a function for me that reads a CSV file

Strong (the new method):

1Goal: create a small command-line tool that accepts any messy CSV,
2tidies it up, and stores a clean version.
3Finished means:
4> it handles missing entries and odd date formats
5> it includes tests, and every test passes
6> there's a brief README explaining how to use it
7Carry it through start to finish. Don't check in with me between steps.
8Halt only once all tests pass or you're genuinely stuck.

Notice the contrast? The second version hands off the entire job. It defines what "finished" means, so the model can measure its own output against it, which is precisely what Fable was built to do

This is the whole mental pivot

Everything that follows is simply how to configure it so it can truly run

Getting set up: give it a space to work in

To allow an AI to run an actual project, it needs somewhere to do the work - read files, write files, execute commands, and verify results. That place is called a coding agent. The most widely used one is Claude Code, which operates in your terminal

You don't have to be a programmer to follow along. Picture it as opening a workspace where the AI has hands, not merely a mouth

Set it up (a single line, if Node.js is on your machine):

1npm install -g @anthropic-ai/claude-code

Then move into a new folder for your project and launch it:

1mkdir my-first-project
2cd my-first-project
3claude

That's all. You now have a space where the AI can genuinely build things rather than just describe them

Passing off your first project

Now for the enjoyable part. Rather than chatting, you give it the goal file. Create a plain text file that outlines the project:

1# put your project brief into a file the agent will read
2cat > GOAL.md << 'EOF'
3# Project: CSV cleaner
4Build a command-line tool that tidies messy CSV files.
5## Finished means
6- reads any CSV, even with missing entries and mixed date formats
7- writes a tidied copy next to the original
8- includes automated tests, and every one passes
9- has a brief README with one usage example
10## How it should work
11- Plan before building.
12- After each piece, run the tests yourself and repair what fails.
13- Do NOT pause to ask me between steps.
14- Stop only once all tests pass, then summarize what you accomplished.
15EOF

Then, within the agent, you direct it to that brief and set it free:

1Read GOAL.md and build the entire thing. Keep working until it's finished.

And now you step away. Brew some coffee

This is the moment that feels odd the first time, because nothing requires you

The model reads the brief, builds a plan, writes the code, runs the tests, watches three fail, repairs them, reruns them, and continues on

That self-verifying loop is what earlier models couldn't maintain. Fable keeps the goal in mind the entire way through

Three rules that make this genuinely work

Passing off a project is a skill

Here are the three factors that separate "it built the entire thing" from "it drifted off and created a mess."

> Turn "finished" into something a machine can verify

"Make it good" isn't a finish line - good never truly arrives, so it never halts

"All tests pass" is an actual finish line - true or false, no debate

Give it a benchmark it can measure itself against, and it recognizes when to stop

This is the one most crucial line in your brief

> Hand it the complete picture from the start

Fable can now process more than text - it grasps screenshots, diagrams, dense tables, and PDFs

So if you're recreating a screen, give it a screenshot. If the rules are stored in a PDF, hand it the PDF

It reasons based on the visual, not merely the words you typed

The more context you provide at the outset, the less it has to guess

> Let it run, but keep a limit in place

A model that operates for hours also burns money for hours, and Fable isn't inexpensive - it costs more and consumes usage faster than earlier models

So before stepping away, set a cap

Set a boundary on how long or how much it may run, plus a clear stop condition, so a project that veers off track can't run through the night

Freedom to operate is wonderful. Freedom without an off-switch is an invoice

Does it justify the cost? A candid answer

Let me be direct, since I'm here to offer a candid review

Fable 5 is sluggish and pricey

For fast questions like "what's this error," "rephrase this email", it's excessive, and a cheaper, quicker model is the wiser pick

Using Fable for minor tasks is like hiring a crane to hang a picture

Where it justifies its cost is the long, tedious, multi-step jobs that would normally eat up an afternoon

An entire small tool. The complete cleanup of a cluttered folder. A research task involving fifteen sources. The type of work where the value isn't a clever line, it's a finished product you didn't have to sit through

Give it those, and the cost repays itself in the time you save

Give it a one-liner, and you're simply burning money

Choose the tasks where "run for an hour and complete it" is worth more than "reply in three seconds."

That's the entire rule

What this truly means

For two years, AI's limitation wasn't its intelligence

It was that you needed to be involved at every single step

You were the chokepoint

That chokepoint is what just gave way

The new skill isn't prompting - it's delegating

Crafting a clear brief, defining what "finished" means, providing the context, setting a reasonable limit, and trusting it to run

It's less like conversing with a chatbot and more like supervising a very fast, very literal junior employee who never tires

The winners here won't be the people with the cleverest prompts

They'll be the ones who grew comfortable passing off entire projects and stepping away

Where this heads next

This covered the mindset and the basic setup

But you can take it much further, and that's what Part 2 covers

I'm already drafting it, and it's the advanced playbook:

• how to craft briefs that get it right the first time, with actual templates you can reuse
• how to run multiple projects simultaneously, in parallel, without them interfering with each other
• how to supply it screenshots and PDFs so it captures designs and rules precisely
• the precise limits and caps I use so a long run never hits me with a surprise bill
• the three projects I now fully hand off and never touch

If this shifted how you think about working with AI, follow me so you don't miss part two

I'm putting my entire actual setup into it

Stop typing out questions

Start passing off projects - that's the entire game now

GIF

@insomnia_vip