# Ask Fable

> Dispatches a task to a Claude Fable 5 subagent with a prompt written the way Fable 5 wants to be prompted, and holds a back-and-forth with it across turns. Use when the user says /ask-fable, ask fable, fable, fable 5, send this to fable, hand this off to fable, get a Fable second opinion, or when a task sits at the top of the difficulty range: multi-hour or multi-day implementations, deep debugging, whole-repo review or bug hunts, dense technical screenshots, or ambiguous multithreaded requests where first-shot correctness matters.

- Skill: `antoniocascais/ask-fable` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add antoniocascais/ask-fable`
- Raw SKILL.md: https://api.skillmd.com/api/skills/antoniocascais/ask-fable/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: antoniocascais (https://skillmd.com/u/antoniocascais)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/antoniocascais/ask-fable

---


# Ask Fable 5

Turn the user's ask into a Fable-shaped task prompt and hand it to the `fable` subagent. Behavioral tuning (scope discipline, honest progress reporting, no early stopping, delegation, report style) already lives in the agent definition. Write the task, not the personality.

Task: $ARGUMENTS

## 1. Check the fit

Fable 5 is for the hard end of the range. Route elsewhere when:

- The task is a routine edit or a quick lookup — just do it in-session, or use a normal subagent. Say so rather than dispatching.
- The task touches offensive cybersecurity (exploits, malware, attack tooling) or biology and life sciences (lab methods, molecular mechanisms). Fable runs classifiers on those domains and returns `stop_reason: "refusal"` even for benign work. Handle it in-session or with an Opus subagent.

If the ask is vague, ask one or two clarifying questions before dispatching. Fable navigates ambiguity well, but a run this expensive should not start pointed at the wrong target.

## 2. Write the prompt

Include, in this order:

**The why, not only the what.** Highest-leverage addition. Context lets Fable connect the task to relevant information instead of inferring intent.

```
I'm working on [larger task] for [who it's for]. They need [what the output enables].
With that in mind: [request].
```

**The definition of done.** Concrete enough that a verifier subagent could check it against a specification.

**Starting context.** Paths, repos, commands to run, constraints, decisions already made — everything established in this session that Fable would otherwise re-derive from scratch.

**Verification cadence**, for anything long-running:

```
Establish a method for checking your own work at an interval of [X] as you build.
Run this every [X], verifying against the specification with subagents.
```

**A notes path**, when the work spans sessions or should accumulate lessons. Fable performs notably better with somewhere to record them.

Then dispatch, with a stable topic-scoped name so the agent stays addressable for follow-ups:

```
Agent(
  name: "fable-<short-topic>",     // scoped, so two invocations don't collide
  subagent_type: "fable",          // any type EXCEPT fork
  description: "<3-5 words>",
  prompt: "<the above>"
)
```

Never use `subagent_type: "fork"`. Fork inherits the parent's model, so the spawn silently runs on your model instead of Fable's — you would be talking to yourself.

Front-load the prompt. A non-fork subagent inherits **none** of your context and there is no second chance to pick it up later. Brief it like a colleague who just walked in: background, what has already been tried, exact paths, the facts it needs. Under-briefing is the most common way to get a weak answer out of Fable.

## 3. Follow-ups

To continue the SAME conversation with its context intact, use `SendMessage` — do not call `Agent` again, which starts a fresh agent with no memory of the exchange:

```
SendMessage(to: "fable-<short-topic>", summary: "<5-10 words>", message: "<your reply>")
```

The name keeps working after the agent finishes; a send resumes it from its transcript. That is also why the name must be topic-scoped — reusing a bare `"fable"` across two different asks can resume the wrong prior conversation.

**This flow needs top-level invocation.** Named, addressable agents only exist when you are the main thread. If this skill is itself running inside a subagent, `name` is silently unavailable ("Only synchronous subagents are supported") — the spawn still works, but `SendMessage` cannot reach it and the conversation is lost. When nested, use single-shot `Agent` calls that re-paste the full context each time.

## 4. Autonomous runs

When the user will not be watching (overnight, background, scheduled), append:

```
You are operating autonomously. The user is not watching in real time and cannot answer
questions mid-task, so asking "Want me to…?" or "Shall I…?" will block the work. For
reversible actions that follow from the original request, proceed without asking.
```

## 5. Relay the result

The agent's report is not shown to the user. Lead with the outcome, then whatever it needs from them. Do not pad it with commentary.

## Caveats

- Fable runs long: many minutes per turn, hours for autonomous work. Tell the user up front so a silent gap does not read as a hang.
- Never instruct Fable to echo, transcribe, or explain its internal reasoning as response text. That trips the `reasoning_extraction` refusal category and falls back to Opus.
- Resist over-specifying. Prompts and skills tuned for earlier models are usually too prescriptive for Fable 5 and degrade its output. State the goal and the constraints; let it pick the method.

Full prompting guide: `references/prompting-fable-5.md`.