Latest / AI Fire Daily / #531 Neil: Fable 5 Workflow Makes Opus Check Itself Before Saying Done
Transcript
- 0:00Why do we always let artificial intelligence
- 0:03just guess the answer? Right. We expect this
- 0:06instant gratification from our digital tools.
- 0:08Yeah. But a human expert never starts without
- 0:10a solid plan. Human experts naturally build a
- 0:14mental scaffolding before they even touch their
- 0:16tools. Exactly. They define the boundaries of
- 0:18the problem first. Which is exactly what we need
- 0:20to teach our AI. Welcome to the deep dive for
- 0:23today. We are exploring a fascinating structural
- 0:26shift with you. It's a huge shift, honestly.
- 0:29Our mission today is unpacking a highly specific
- 0:32blueprint to transform your AI usage. We are
- 0:35going to recreate the coveted Fable 5 workflow.
- 0:38inside Claude. And we want to specifically focus
- 0:41on the Okus model for this framework. It is really
- 0:45important to implement this before usage windows
- 0:47potentially change. Right, because we aren't
- 0:49just looking for one good AI output to solve
- 0:52a single problem. Yeah, a good answer only helps
- 0:54you one single time. We want to capture a repeatable
- 0:57working style that you can actually scale. That
- 1:00style spans across five distinct structural steps
- 1:03we will explore. Those steps are scope, evidence,
- 1:07attack, verify, and finally, report. It sounds
- 1:10like a lot, but it flows incredibly well once
- 1:13you set it up. We are also looking at two distinct
- 1:15tools today as we build this out. CloudChat is
- 1:19generally designed for quick browser -based tests.
- 1:22But Claude Code is built for deep, real -world
- 1:26project work. It's amazing. It actually reads
- 1:28your local project files directly from your terminal.
- 1:31That local integration changes everything about
- 1:34how the AI reasons. But whether you use the browser
- 1:36or the terminal, the framework remains identical.
- 1:39Right. You have to force the model through these
- 1:41five specific cognitive checkpoints. Okay, let's
- 1:44unpack this first crucial phase together. Step
- 1:46one is about scoping the task thoroughly before
- 1:49generating anything. Because you really cannot
- 1:51execute a task you don't fully understand. It's
- 1:54like hiring a contractor to remodel your house.
- 1:56You would never let them just start swinging
- 1:58a sledgehammer immediately. No, I mean, that
- 2:00would be a disaster. Right, they have to measure
- 2:02the entire kitchen before they even buy materials.
- 2:04Yet that is the root of most AI failures today.
- 2:07Users just hand over a prompt and expect immediate
- 2:10execution. They just hit enter and hope for the
- 2:13best. Exactly. The AI starts writing long before
- 2:16it actually comprehends the deeper goal. Step
- 2:18one forces the OPUS model to significantly slow
- 2:22down its processing. We actually instruct it
- 2:24to write out a project scope first. It must define
- 2:27what the real task actually entails. It needs
- 2:29to visualize what the final output should look
- 2:32like formatting -wise. It also must map out all
- 2:34the constraints you provided in the prompt. I
- 2:37have to admit, I still wrestle with prompt drift
- 2:39myself. Well, we all do. It's so easy to slip
- 2:41into. I will ask for one small structural change
- 2:45to a draft, and I end up with a completely rewritten
- 2:48thematic mess. Yeah, that happens because the
- 2:51model lacks a proper rigid scope. It just starts
- 2:53predicting the next logical token without a boundary.
- 2:56Opus prevents that drift by explicitly defining
- 2:58those boundaries early on. When you use Claude
- 3:01code, this scoping phase becomes even more powerful.
- 3:04Opus actually checks your surrounding project
- 3:06files before scoping anything out. It understands
- 3:09the entire neighborhood before it tries to build
- 3:11the house. Two -sec silence. That makes the first
- 3:15step incredibly grounded in reality. It completely
- 3:19stops the model from guessing what good means
- 3:21for your project. If you want a publish ready
- 3:23section, it knows that specific standard. If
- 3:26you want a quick review, it consciously decides
- 3:28to stay brief. That is the fundamental Fable
- 3:315 habit we want to copy here. You must force
- 3:34the AI to understand the job before doing the
- 3:37job. You do this by asking it to generate a scope
- 3:39outline first. Before we move on, I have a practical
- 3:42question about this phase. What is the actual
- 3:45time cost of forcing Opus to do this deep scoping
- 3:48on simple everyday tasks? Well, it might add
- 3:5230 seconds of processing up front for the AI,
- 3:54but it genuinely saves you three hours of frustrating
- 3:57manual rewrites later on. So you sawn it for
- 4:00quick fixes, Opus for deep planning? Exactly.
- 4:03It is the ultimate return on investment for your
- 4:05time. But scoping is really only half the battle
- 4:07here. Just because Opus understands the blueprint
- 4:09doesn't mean it has the lumber to build it. Right.
- 4:11You need the actual raw materials. How do we
- 4:14prevent it from hallucinating the missing pieces?
- 4:17That brings us directly to the concept of checking
- 4:19evidence. Step two is strictly about separating
- 4:23verified evidence from wild assumption. Before
- 4:26OPUS explains, writes, edits, or makes any final
- 4:30decision, it must carefully review the real inputs
- 4:32provided in your prompt. We explicitly tell the
- 4:35AI to audit its available materials. These inputs
- 4:38could be an article draft or your personal source
- 4:41notes. It could be screenshots or a detailed
- 4:43transcript from a meeting. For software engineers,
- 4:45it might be a specific local file path. It could
- 4:48be a terminal error message or a broken function
- 4:50name. Opus must declare what is clearly available
- 4:53to it right now. It looks directly at what we
- 4:55call the context window. Let me quickly define
- 4:57that technical term for clarity. Context window.
- 5:01The short term memory the AI uses to read files.
- 5:04That memory has a hard limit, which is why evidence
- 5:07checking matters. Opus scans that short term
- 5:09memory to find the actual evidence. We prompt
- 5:11it to explicitly state what crucial information
- 5:13is currently missing. It has to highlight which
- 5:16claims require further human verification. Most
- 5:20importantly, it lists what absolutely cannot
- 5:23be assumed based on the text. Right, and that
- 5:25changes the entire dynamic of the interaction.
- 5:27But I have to push back on this underlying premise
- 5:29slightly. Sure, go for it. Does the AI actually
- 5:32admit when it lacks sufficient evidence? Or does
- 5:35it just try to please the user by faking it?
- 5:38Left entirely to its own devices, it will absolutely
- 5:40try to please you. The default behavior is to
- 5:43give you a complete, satisfying sounding answer.
- 5:46It wants to be helpful, even if it's hallucinating.
- 5:48Exactly. But the Fable 5 prompt structure fundamentally
- 5:52rewrites those rules of engagement. You are not
- 5:55asking it for an answer yet. You are only asking
- 5:57it for an inventory report. How does the system
- 5:59prompt actually force that compliance? We use
- 6:02strict structural tags in the initial instructions.
- 6:05It cannot move forward without that explicit
- 6:07declaration of missing files. This keeps the
- 6:09final answer from sounding falsely confident
- 6:11later on. It essentially prevents the model from
- 6:13standing on a shaky foundation. It checks the
- 6:16input first, then it eventually builds the answer.
- 6:19It builds only from what is actually verified
- 6:21in the text, to sex silence. This brings up a
- 6:25technical distinction I want to explore. How
- 6:27does Claude Code handle this evidence check differently
- 6:30than Claude Chat? Well, Claude Chat relies strictly
- 6:33on the text you manually paste into the conversation.
- 6:36Claude Code proactively inspects the actual files
- 6:39sitting in your local folder. Chat relies on
- 6:42pasted text. Code reads your actual project files.
- 6:45Yeah, it flags unsupported technical claims before
- 6:48it ever changes your code. Sponsor. Welcome back
- 6:51to our deep dive into the Fable 5 workflow. We
- 6:54have a clear scope and we have verified our evidence.
- 6:56But the initial plan the AI creates is usually
- 6:59still quite flawed. We need to pressure test
- 7:02that blueprint before we start the actual build.
- 7:04Step three is the absolutely necessary pressure
- 7:07test phase. Before Opus writes a paragraph or
- 7:10codes a function, it reviews its own plan. We
- 7:12prompt Opus to act exactly like a critical senior
- 7:15reviewer. We are asking it to pout holes in its
- 7:18own logic. It's forced to be its own toughest
- 7:20critic. Whoa. Imagine an AI actively trying to
- 7:24break its own logic before typing a word. Beat.
- 7:27That is a massive cognitive shift from how we
- 7:30normally use tools. It completely flips the traditional
- 7:33prompt and response dynamic on its head. It actively
- 7:36attacks the plan to catch weak assumptions early
- 7:39in the process. It explicitly asks itself what
- 7:42steps are most likely to fail entirely. It looks
- 7:45for places where the logical flow could easily
- 7:47break down. It searches for simpler or much safer
- 7:50approaches to the core problem. It doesn't just
- 7:53blindly follow your initial prompt anymore. It
- 7:55tests the proposed plan. then it improves that
- 7:58plan before working. If you're using Claude code
- 8:01in a complex environment, this is vital. It ensures
- 8:04the new plan won't accidentally break nearby
- 8:07connected files. It ensures it won't edit the
- 8:09wrong section of a delicate script. Even a very
- 8:12clean -looking plan can rest on terribly weak
- 8:14assumptions. You might ask for a rewrite that
- 8:17ends up sounding much better. But it could drift
- 8:19entirely away from your real creative brief.
- 8:21The attack phase catches that stylistic drift
- 8:24before the generation happens. Or you might get
- 8:27a code fix that solves the visible error perfectly,
- 8:31but it silently breaks something crucial in a
- 8:33related database file nearby. That is the Fable
- 8:365 habit we are copying here today. Challenge
- 8:39the architectural plan before ever executing
- 8:42that plan. So what actually happens if the plan
- 8:46is deemed too risky by the AI? It halts the entire
- 8:50execution process immediately without making
- 8:52changes. It clearly explains the specific risk
- 8:55and asks you for further clarification. It stops,
- 8:58flags the risk, and asks you for clarification.
- 9:01It refuses to proceed until that identified risk
- 9:03is humanly mitigated. Let's say the plant survived
- 9:06the rigorous attack phase successfully. The execution
- 9:09actually happened based on that newly improved
- 9:11blueprint. But we are not completely finished
- 9:13with the workflow just yet. Human nature is to
- 9:15blindly trust a really clean -looking output.
- 9:18Step four is designed to stop that dangerous
- 9:20tendency completely. Verification means aggressively
- 9:23comparing the final generated result against
- 9:25multiple things. We force the AI to check it
- 9:28against the original request you made. We check
- 9:31it against the gathered evidence from Step 2.
- 9:33We check it against the improved plan we created
- 9:36in Step 3. The ultimate goal is to catch anything
- 9:39that remains unsupported. We actively look for
- 9:42off -format text or logically weak arguments.
- 9:45Here is a crucial point to remember for implementing
- 9:48this workflow. When the AI finds a mismatch,
- 9:52Opus should only fix the exact failing parts.
- 9:55We should never do a full, sweeping rewrite of
- 9:58the entire output. Absolutely not. That introduces
- 10:01way too much chaos. It's like finding a typo
- 10:03in Chapter 3 and only reprinting that page, instead
- 10:06of burning the whole book. If you rewrite the
- 10:08whole book, you might introduce ten new typos.
- 10:10That is the perfect way to visualize the danger
- 10:12of full rewrites, when the initial answer mostly
- 10:15matches your original scoped request. You absolutely
- 10:17do not want a complete rewrite just to sound
- 10:20slightly better. If a logical gap shows up...
- 10:22Opus fixes that exact localized part. It leaves
- 10:26the rest of the highly functional text entirely
- 10:29alone. In Claude Code, this targeted verification
- 10:31applies directly to your local files. Opus verifies
- 10:35the updated file immediately after making the
- 10:37specific edit. It doesn't rely solely on the
- 10:40chat interface memory to assume success. It reads
- 10:43the newly saved file to ensure the patch actually
- 10:46worked. This verification loop stops Opus from
- 10:49ending the task prematurely. A result can look
- 10:51wonderfully finished while entirely missing the
- 10:54real request. You might get a smooth, persuasive
- 10:57section that completely skips a word count constraint.
- 10:59Or a code change that successfully fixes one
- 11:02specific isolated issue while leaving a deeply
- 11:05related dependency file completely untouched.
- 11:08We absolutely must verify the final output before
- 11:11saying we are done. Two secs silence. Quick question
- 11:13on this verification step. Why exactly is a full
- 11:16rewrite a bad thing if the AI offers it? Sweeping
- 11:20rewrites introduce brand new variables and completely
- 11:23unverified assumptions. Pinpoint fixes isolate
- 11:26the specific error without destroying the existing
- 11:29structure. Full rewrites introduce new errors.
- 11:31Pinpoint fixes protect what already works. Protect
- 11:34the established foundation at all costs during
- 11:36the verification phase. The work is finally done
- 11:39and it has been fully verified. But for the user
- 11:42to truly trust this entire automated process,
- 11:45the AI needs to handle work over with complete
- 11:47transparency. Step 5 completely eliminates the
- 11:51incredibly vague done message we usually get.
- 11:54Reporting means OPUS explicitly tells you what
- 11:56it actually did behind the scenes. It must clearly
- 11:59explain what specific tasks were fully completed.
- 12:02It details what exactly changed after the verification
- 12:05pass caught an error. It also states clearly
- 12:07what is still considered uncertain or unresolved.
- 12:11Confidence calibration is the absolute core of
- 12:13this final reporting step. OPUS explains exactly
- 12:16how sure it is of the final result. It bases
- 12:19the score on the task complexity of the evidence
- 12:22and the verification. If something remains mathematically
- 12:24or logically uncertain, it shouldn't hide it.
- 12:27It shouldn't mask its own structural doubt behind
- 12:29a very confident, authoritative tone. This reporting
- 12:32step makes the entire Fable workflow much easier
- 12:34to trust. You get the actual final output, plus
- 12:37the detailed status behind the output. This provides
- 12:40immense psychological comfort to the daily user.
- 12:43It transforms the AI from a mysterious, unpredictable
- 12:47black box. It becomes a highly transparent and
- 12:50surprisingly honest collaborator. You aren't
- 12:53just crossing your fingers and hoping the code
- 12:55actually compiled. You know exactly what Opus
- 12:57reviewed in the background while you waited.
- 12:59You know what it checked, what it fixed, and
- 13:01where to be careful. Claude Code helps this final
- 13:04report reflect the true project state. The final
- 13:07report comes from reading the actual altered
- 13:10project files. It doesn't just come from the
- 13:12short -term memory in the chat window. Don't
- 13:14just finish the task. Explain exactly how solid
- 13:17the work is. So what should a user do if Opus
- 13:20reports back with low confidence? You read the
- 13:23final report, find the missing context, and supply
- 13:26it. Then you simply let the system run the five
- 13:28-step loop again. You step in... provide missing
- 13:31context, and run the loop again. That is the
- 13:34true iterative loop of modern human AI collaboration.
- 13:38We are getting ready to wrap up our deep dive
- 13:40today. Let's summarize the overarching theme
- 13:43we explored throughout this entire framework.
- 13:46The true lasting value of the Fable 5 model isn't
- 13:49magic. It isn't a secret proprietary algorithm
- 13:52or a hidden beta feature. It is a strict structural
- 13:56discipline applied to artificial thought. It
- 13:59is fundamentally about capturing a highly repeatable,
- 14:03scalable working style. Let's recap the exact
- 14:06conversational flow briefly for you to remember.
- 14:09Understand the job before you make any assumptions
- 14:11about the output. Check the materials you actually
- 14:14have in your hands right now. Attack the blueprint
- 14:16aggressively to find the hidden logical flaws.
- 14:19Verify the final build against the original constraints
- 14:22of the request. And finally, rigorously report
- 14:25the true integrity of the finished work. ClaudeChat
- 14:27is generally enough for a quick, simple text
- 14:30test. But Claude code makes absolute sense for
- 14:33real, complex, local files. You're finally giving
- 14:36Opus a rigid structure it can reuse repeatedly.
- 14:38The final, generated answer feels much more grounded,
- 14:41nuanced, and trustworthy. Two -second silence.
- 14:45I want to leave you with a final thought today.
- 14:46Something to mull over as you go about your work
- 14:48this week. It is a really fascinating philosophical
- 14:51pivot from our technical discussion. If forcing
- 14:54an AI to scope and find evidence works this well,
- 14:57if forcing it to actively attack its own assumptions
- 15:00produces vastly superior results. Think about
- 15:03the broader implications for our own human collaboration.
- 15:06How much better would our own human teams perform
- 15:08on complex projects? What if we rigidly applied
- 15:11this same five -step fable workflow to ourselves?
- 15:14What if we used it in our own daily stand -up
- 15:16meetings? We constantly expect instant answers
- 15:19from ourselves and our busy colleagues, but maybe
- 15:21we really need to slow down to actually speed
- 15:23up. Maybe we need to attack our own plans much
- 15:25more often. Thank you for joining us on this
- 15:28deep dive. Outtero music.