Fable 5: The GOAL Framework + Loops

FABLE IS CANCELLED. The US government ordered Anthropic to take down Mythos due to security concerns since it is too powerful….I know lol. Nevertheless a lot of these models tips can apply to OPUS 4.8, the next most powerful model Just replace everything with OPUS 4.8 Instead.

How to point Claude Fable 5 at a goal, let it run, and wrap it in a loop. Beginner to intermediate.

Most people are using Fable 5 like it's the old models — handing it a step-by-step task list. Wrong gear. Fable does the whole job from one prompt. So the question you ask changed:

• Old way: is it doing the work right? (you wrote the steps)
• Fable way: is it doing the right work? (you wrote the destination)

You're not a manager handing out tasks anymore. You're a director handing over a goal. This guide gives you the framework, three copy-paste prompts, and how to set up a loop that keeps shipping without you babysitting it.

The one shift

Old models needed steps: "research X, draft Y, publish Z." Fable needs a destination: "a visitor knows what I do in 5 seconds and books a call." It picks the route — often a better one than you'd have chosen. So give it a goal, not a task, and always point it at something real first.

Prompt 1 — the GOAL prompt (fill in the blanks)

This is the shape of a high-quality Fable prompt. Copy it, swap the brackets.

Here is [the thing I already have] in this folder: [path].
Read all of it first and map what it does today.

My goal: [what "done" looks like in plain language — the end state, not the steps].
Turn this into testable criteria. Interview me if anything is fuzzy,
and check the criteria with me before you build.

The how is yours. Explore the files, pick the approach, decide what to
change and in what order. Match the design and patterns already there.
Don't ask me how — just tell me where you landed.

Build it. Verify it actually works (run it / open it in the browser with
real data), not just claim it's done. Check in with me before any big or
hard-to-undo decision.

Finish by showing me [the proof I want] and where each piece came from.

Prompt 2 — the interview (when you don't know your goal)

Sometimes you can't write a clean goal. Flip it. Make Fable interview you first. You ramble, it asks the sharp questions, then it writes the master prompt for you. This is the reverse-prompt.

I have a project for you, but I'm not ready to brief you. Interview me first.
Ask one question at a time, in plain language. You're learning four things:

1. What I already have. Files, a folder, a site, a doc, a system. Get the
   location, then read all of it yourself before asking me anything you
   could answer on your own.
2. What I want it to become. Push past vague answers — if I say "make it
   better," ask what better looks like and how we'd both know it happened.
   Turn my answers into specific, testable criteria.
3. What's mine vs yours. Find the decisions I actually care about. Anything
   I don't claim is your call.
4. What proof I need to trust it's done. Ask how I want it verified — open
   in the browser, tested with real data, whatever.

Keep it short: 5–7 questions, then stop. Make reasonable calls on small
stuff yourself. Then write everything back to me as one master prompt.
When I approve it, execute it, and check in before any big or hard-to-undo move.

Why this is worth it: you can brain-dump and still miss things. The interview catches what you'd have forgotten, and it turns your answers into the testable criteria the checker agents use to verify the work.

Prompt 3 — build a loop (where this gets unfair)

A single good prompt is great. A loop is a different league. A loop is Fable picking the next most valuable task, shipping it, checking its own work, logging what it learned, and going again — on a schedule or until the job's done. Three days ago loops felt impossible. Now they're the most important thing you can set up.

How to build one:

1. Go to your agent. Explain what you're building.
2. Ask what loop system it would build and which tools, files, and checks it needs to ship and review work on repeat. Let it recommend
3. Build the plan it gives you.
4. Run it. Then run it again. Every pass, find one thing to tweak, fix, or improve.
5. The more you run the loop, the better it gets.

Use this to kick it off:

I want a loop that runs without me babysitting it: it picks the next most
valuable piece of work, ships it, reviews its own work, and logs what it learned.

First, before building anything: look at what I have here [path], tell me
what a good loop looks like for this, and which tools / files / checks you'd
need to run it safely on repeat. Recommend, don't survey.

Once we agree, every run of the loop should:
1. Read the goal and the current state.
2. Pick the single highest-value task toward the goal.
3. Do it.
4. Verify it actually works — run / open / test with real data. A fresh
   check, not just self-praise.
5. Write one lesson to a memory file at [path]: one lesson per entry,
   one-line summary at the top, so the next run is smarter.

Read that memory file at the start of every run and update it at the end.
When the goal's acceptance tests all pass, say so and stop.

To actually run it on repeat in Claude Code: type /loop followed by your prompt or a slash command. Give it an interval (e.g. every 30 minutes) or leave the interval off and let Fable pace itself.

How to switch Fable on

1. Open Claude Code in your terminal.
2. Type /model and pick Fable.
3. For the heavy multi-agent runs (the orchestrator that spins up sub-agents to do the work and sub-agents to check it), type /effort and choose the dynamic-workflow / Ultracode option.

The orchestrator can spawn many sub-agents to do the work, then more sub-agents to verify it. Powerful — and not free. See the spend note below.

Make Fable behave (intermediate tips)

• Give it the reason, not just the request. "I'm building X for Y. They need Z. With that in mind: [request]." It connects the dots far better when it knows why.
• Make it prove progress. Add: "Before reporting progress, check each claim against an actual result. If it's not verified, say so." Kills fake "all done" reports.
• Give it a memory. Point it at a notes file, tell it to write one lesson per entry and read it next session. It compounds — gets sharper every time.
• For hands-off / overnight runs, add: "You're operating autonomously. Don't ask permission for reversible steps — just do them. Don't end your turn on a promise; finish the work first."
• Pick your effort. High for most jobs, xhigh for the hardest, low or medium for routine. Even low Fable beats the old models maxed out — drop the effort if a job finishes right but slow.
• Expect long turns. One request can run 10–15 minutes while it gathers context, builds, and checks itself. That's normal. Don't kill it.
• Just asking a question? Say so: "Assess and report — don't change anything yet." Otherwise it may helpfully go and do it.

Watch your spend

Fable is a heavy model — roughly twice the cost of Opus — and dynamic workflows can spin up a lot of sub-agents. Worth it for hard jobs and loops. Overkill for a one-line edit. Match the tool to the task and keep an eye on your limits.

The 30-second version

Point it at something real. Tell it the destination, not the steps. Let it pick the path. Make it prove it worked. Then wrap it in a loop and run it till it's good. tweaking one thing each pass.

Prompt 4 — the all-in-one (generates your goal + loop)

Don't want to write the goal and the loop separately? Paste this one prompt into a fresh session, drop your problem in, and it reverse-engineers both — a goal spec with PASS/FAIL acceptance tests, and the loop that drives toward it — and hands them back ready to run.

I want you to set up a goal-and-loop system for a problem, then hand me back
copy-paste prompts so I can run it. Do NOT start building the actual solution
this session — your only job now is to produce the goal and the loop.

THE PROBLEM I WANT SOLVED:
[describe it here — blah blah. Plain language. The end state, not the steps.]

WHAT ALREADY EXISTS (read this before anything else):
[path / folder / repo / doc — or write "nothing yet, greenfield"]

Do this, in order:

1. GROUND. Read everything at the path above before you reason. If it's
   greenfield, say so. Don't guess what I have.

2. INTERVIEW. If anything is fuzzy, ask me up to 5 short questions, one at a
   time, then stop. If it's clear enough, skip this and just state the
   assumptions you're running with.

3. WRITE THE GOAL (this is my /goal). Create goal.md as the single source of truth:
   - The target in one paragraph — what "done" looks like.
   - 5–10 acceptance tests, each a concrete PASS/FAIL check I could verify myself
     ("opening X shows Y with real data", not "X works well").
   - A self-test section: the exact steps/commands to check each test and print
     PASS or FAIL per line.

4. WRITE THE LOOP (this is my /loop). Give me, as one copy-paste block, a
   loop-driver prompt that on every run:
   - reads goal.md and the current state,
   - runs the self-test and notes which acceptance tests still FAIL,
   - picks the single highest-value task that flips a failing test to PASS,
   - does it,
   - verifies for real (run / open / test with real data — a fresh check, not
     self-praise),
   - writes one lesson to memory.md (one lesson per entry, one-line summary on top),
   - STOPS the moment every acceptance test in goal.md passes.

5. TELL ME HOW TO RUN IT. Give the exact start command
   (Claude Code: `/loop [interval] <the loop-driver prompt>`), and say whether
   you'd run it on an interval or self-paced, and why.

Output, clearly labelled: (A) goal.md  (B) the loop-driver prompt  (C) the run command.
Recommend, don't survey. Check with me before any big or hard-to-undo decision.

Optional upgrade: tell it to save the goal as a skill so you can loop it directly with /loop 30m /yourgoal.