⚖️ Not every task calls for Fable 5
🧠 Imagine it this way: hiring a senior architect to tell you what time it is. They may get it right, but you paid an architect’s day rate for a wristwatch task. Using Fable 5 to summarize a paragraph is the same waste — just in focus, depth, and execution time.
Fable 5 was built to maintain context, make chained decisions and sustain reasoning over long runs. That takes focus: when you point this capability at a two-minute task—summarizing a short text, answering a quick factual question—there’s no “extra” capacity being used. You’ve just paid for an advanced model to do a simple model’s work.
The real benefit shows up at the other end of the spectrum: when the task requires keeping the whole picture in mind at once. Review an entire project's architecture, assess product/technology/business risks, turn a loose idea into an execution plan, analyze long documents, review code/security/UX/databases, organize complex strategies, create diagnostic and tracking systems — all of this calls for sustained depth, not a quick answer.
🧭 Practical rule
If you could resolve this with a 2-minute scan, it’s not a task for Fable 5. If it requires keeping dozens of variables/files/decisions in mind at once to reach a correct answer, that’s exactly what it’s for.
✗ Waste
- • Summarize a short text
- • Answer a quick factual question
- • Edit a sentence or caption
- • Generate 3 standalone title ideas
✓ Worth it
- • Review an entire project's architecture
- • Assess product/technology/business risks
- • Turn an idea into an execution plan
- • Analyze long documents
- • Review code/security/UX/database
- • Organize complex strategies
- • Create diagnostic and tracking systems
In one sentence: Fable 5 is worth it when the task requires keeping the whole picture in mind—not when it fits in a 2-minute answer.
🎯 The senior agent prompt (copy-run)
🧠 Imagine it this way: the difference between asking "give me some ideas" of an intern and asking for a structured report from a senior consultant. The second format requires diagnosis, a decision, risks, and a plan—not a loose list.
This is a prompt tested in practice, not an official documentation quote—it’s a recommended template for when the task has already passed the filter from the previous topic. It works because it replaces “share some ideas” with a numbered list of deliverables: the model tends to cover exactly the items you numbered, in the order you numbered them.
Notice the order of the 6 items: diagnosis first (what's wrong), then decisions and risks (what to do and what could go wrong), only then the plan and deliverables, ending with what to do now. This sequence avoids the classic trap of jumping straight to a solution without understanding the problem.
🔬 Copy-run example: senior analysis prompt
Goal: turn any complex project or situation into a structured senior-agent analysis—diagnosis, decisions, risks, plan, deliverables, and next step—instead of a one-off response.
Estou trabalhando em <projeto maior> para <público>. O resultado final precisa permitir <objetivo real>. Analise o projeto inteiro como um agente sênior. Não me dê ideias soltas. Entregue: 1. diagnóstico do problema central; 2. decisões estratégicas necessárias; 3. riscos; 4. plano de execução em etapas; 5. entregáveis concretos; 6. o que deve ser feito agora, nesta ordem.
How to check: check whether the response presented all 6 items clearly separated and numbered—not one continuous paragraph mixing everything together. If any item is shallow or missing (e.g., risks disappeared), run it again and point out exactly which number was incomplete.
💡 Why numbered structure matters
The model tends to mirror the structure you ask for. Ask for “ideas” and you get loose ideas; ask for 6 numbered deliverables and you get 6 numbered deliverables. The list isn’t decoration — it’s the response format contract.
In one sentence: Ask a senior agent—with numbered deliverables—and you’ll trade loose ideas for an executable plan.
🧠 Why the reason changes the answer
🧠 Imagine it this way: asking someone to “make a slide” without saying who will see it, versus saying “it’s for the board, to approve the budget.” The request is the same; the required result is completely different.
The model responds better when it understands the intent behind the request: what the bigger goal is, who will use the result, what context it fits into, and what the answer needs to enable. Without that, it fills in the gaps with the most generic interpretation possible for that kind of request—which is rarely exactly what you needed.
This isn't a new rule: it's an established prompting practice, tested again here in the specific context of using Fable 5 as a work agent—not a definitive citation from the documentation. Treat it as a solid recommendation validated in practice, not a rule set in stone.
🔗 Further reading (track 1): this tip has the same spirit as the module 1.2 — “Give the why”, which is backed by Anthropic’s documentation and covers the more technical, API-level version of the same principle (including the side effect of asking it to “show its reasoning”). Here, the application is more practical, geared toward everyday products and projects.
✗ Missing context
- • Generic, textbook answer
- • Wrong focus (optimizes the wrong thing)
- • Rework to realign afterward
- • Priorities decided "by guesswork"
✓ With context
- • Response aligned with the real objective
- • Less rework to realign
- • Correct priorities from the first response
- • Explicit criteria for "good," not guessed
In one sentence: without a reason, the model guesses the context; with a reason, it makes decisions in your direction.
🔁 Weak vs. strong: the same request, different contexts
🧠 Imagine it this way: "create an AI learning path" is a shouted order from afar. The strong prompt below is the complete brief—who will use it, for what, and what the learning path needs to deliver in the end.
See the same request in both versions. The difference isn't in the "what" — both ask for a 30-day learning path. The entire difference lies in the reason: who the audience is, what they need to achieve, and how that translates into a 6-part structure instead of a loose list of days.
🔬 Copy-run example: weak vs. strong
Goal: show how the same request shifts from a “generic list of topics” to a “structured plan with progress criteria” just by adding who the audience is and what they need to achieve.
❌ FRACO: Crie uma trilha de IA. ✅ FORTE: Estou criando uma trilha para profissionais que querem aprender IA de forma prática e aplicar no trabalho. O objetivo é fazer a pessoa praticar todos os dias e construir projetos reais. Com isso em mente, crie uma trilha de 30 dias com: 1. diagnóstico inicial; 2. prática diária; 3. projeto simples por semana; 4. conteúdo de apoio; 5. critério de evolução; 6. resultado final esperado.
How to check: run both versions and compare. The weaker one tends to return a generic 30-day list with no progression or criteria for “whether you improved.” The stronger one returns the 6 requested parts, including daily practice and criteria for improvement — because the reason (practice every day, real project) guided the structure. If the stronger version is still vague, reinforce concrete numbers/criteria in the “who” and the “why.”
In one sentence: same request, completely different result—the only variable was the reason.
🔗 The combo in practice: the right task + the reason from the start
🧠 Imagine it this way: instead of two separate requests (first choosing the right task, then explaining the reason in another message), the two tips become a single opening paragraph—the same message starts with the right complex task AND the context that justifies it.
Tips 1 and 2 aren’t sequential steps — they’re the same opening sentence. You choose a task that really calls for depth (it doesn’t ask for a summary) e explain the reason/context right there in the first message — not later, as an addendum after the answer has already come back generic.
Realistic example: a solo founder about to hire their first team member needs to restructure the entire project beforehand—including architecture decisions, priorities, and what to delegate. This is a task where Fable 5 is worth it (tip 1), and the reason (“I’ll use this to make a hiring decision in the next 4 weeks”) completely changes what the response needs to prioritize (tip 2).
Context + reason first
Before the request, not after
Who will use the result, what it's for, and what the response needs to enable—in the first sentence.
Choose a task that calls for depth
The filter from topic 1
Architecture, risk, execution plan—don’t ask for a summary or a quick answer.
Ask for a structured, numbered deliverable
The format from topic 2
Diagnosis, decisions, risks, plan, deliverables, next step — never “loose ideas.”
Check against the reason
After running
Did the response prioritize what you said mattered? If not, reinforce the reason and run it again.
🔬 Copy-run example: combined prompt
Goal: show the prompt from tip 1 (the right task), now paired with the reason from tip 2 (context), in a single opening message—not in two separate requests.
Estou reestruturando <nome do projeto> antes de trazer a primeira pessoa do time. Preciso que esta análise sirva de guia pras próximas 4 semanas de decisões — não é curiosidade, é o documento que vou seguir pra contratar e priorizar. Analise o projeto inteiro como um agente sênior, considerando que quem vai usar isso sou eu sozinho, tomando decisões de arquitetura, prioridade e contratação. Não me dê ideias soltas. Entregue: 1. diagnóstico do problema central; 2. decisões estratégicas necessárias; 3. riscos; 4. plano de execução em etapas; 5. entregáveis concretos; 6. o que deve ser feito agora, nesta ordem.
How to check: confirm that the response explicitly references “the next 4 weeks” and “hiring” in its priorities—that proves the reason influenced the focus and order. If it returned 6 generic items without connecting them to the context you provided, the reason wasn't explicit enough.
In one sentence: the right task + an explicit reason, in the same opening message—not in two separate requests.
☑️ Common mistakes + quick checklist
🧠 Imagine it this way: the two tips in this module fail the same way in practice — not because they’re complicated, but because it’s easy to fall back into the old habit of "just sending the question" under time pressure.
The most common mistakes aren’t conceptual—they’re habits. You know you should provide context, but you’re in a hurry and send only the task. You know the task is large, but you use the same generic prompt as always. The list below is a quick antidote: review it before you hit send, not after you get a generic answer.
✗ Common mistakes
- ✗Use Fable 5 for a 2-minute summarization task
- ✗Ask for “loose ideas” without a delivery structure
- ✗Put the reason at the end of the prompt, like a PS
- ✗Assuming the model “will understand the context” without writing it down
- ✗Repeating the same generic prompt across completely different tasks
✓ Right checklist
- ✓Reserve Fable 5 for analysis/architecture/risk/planning
- ✓Ask for a numbered deliverable (diagnosis → decisions → risks → plan → deliverables → next step)
- ✓Reason + audience + what the output enables BEFORE the request
- ✓State the context explicitly, even if it seems obvious
- ✓Adapt the prompt to the actual task; don't use a generic template
✅ 30-second checklist before sending
- • Does this task require keeping the whole picture in mind (architecture, risk, plan)?
- • Is the reason/context in the first sentence, not at the end?
- • Did I ask for numbered deliverables, not "standalone ideas"?
- • Did I explain who will use the result and what it needs to enable?
In one sentence: before sending — does this task deserve Fable 5? And is the reason already in the first sentence?
🧾 Module Summary
Next module:
2.2 — Control depth + set limits: not every task needs maximum reasoning, and a strong agent needs boundaries before acting.