Files

135 lines
6.3 KiB
Markdown
Raw Permalink Normal View History

---
name: fable-tackle
description: >-
Multi-model orchestration policy for tackling a task: Fable 5.1 orchestrates,
exploration/research is delegated to Sonnet 5 at high thinking, and
coding/implementation is delegated to Opus 5.5 at high thinking. Use whenever
the user invokes /fable-tackle, or asks to "tackle" a task with the fable
multi-model split, or wants exploration on Sonnet, coding on Opus, and the
orchestration/planning on Fable — all three at high thinking. Visual work
(screenshots, image reading, UI/preview verification) also goes to Sonnet 5.
Also trigger on phrasings like "fable-tackle ezt", "fable-vel szervezd",
"sonnet exploráljon, opus kódoljon".
---
# Fable Tackle
A task-execution policy that assigns each phase of work to the model best suited
for it. You are the orchestrator; you delegate the two heavy phases (exploration
and coding) to subagents running specific models at high reasoning effort, and
you keep the planning/synthesis for yourself.
The point: exploration is search-heavy and cheap to parallelize (Sonnet 5, high
thinking), implementation demands the strongest coder (Opus 5.5, high thinking),
and stitching it together — deciding what to explore, what to build, and whether
it's correct — is orchestration (Fable 5.1). Anything _visual_ — reading
screenshots, image content, or driving/verifying the UI in the browser preview —
also goes to Sonnet 5, which handles vision and screenshot-based checks well.
## The model split (the core of this skill)
| Phase | What it covers | Model | Agent model | Thinking |
| ------------- | -------------------------------------------------------------------------------- | ---------------------------- | ----------- | -------- |
| _Explore_ | search code, locate files, gather constraints, read docs, research — _read-only_ | Sonnet 5 (claude-sonnet-5) | sonnet | high |
| _Visual / UI_ | read screenshots & images, drive the browser preview, verify the rendered UI | Sonnet 5 (claude-sonnet-5) | sonnet | high |
| _Code_ | write/edit/refactor/fix, implement the change | Opus 5.5 (claude-opus-5-5) | opus | high |
| _Orchestrate_ | decompose the task, sequence steps, synthesize findings, review, verify | Fable 5.1 (claude-fable-5-1) | fable | high |
Orchestration runs in the main loop — that's you. It works best if this session
is on _Fable 5.1 at high thinking_. If it isn't, say so once (the user can switch
model / raise the thinking level / toggle /fast), then proceed anyway — the
subagent assignments below are what matter most, and you can still orchestrate on
the current model. Since the main loop inherits the session's thinking level,
Fable's "high thinking" comes from the session being set to high effort.
## How to run it
Pick the mechanism by task size.
### Multi-step tasks → use the Workflow tool (preferred)
Workflow is the only mechanism that lets you set _both_ the model and the
thinking effort per subagent, so it honors "high thinking" precisely. Invoking
it here is explicitly sanctioned — this skill's instructions tell you to.
- Orchestration is the script itself (runs on the session model — keep the
session on Fable 5.1 at high thinking).
- Exploration stages: `agent(prompt, { model: 'sonnet', effort: 'high', agentType: 'Explore' })`
- Coding stages: `agent(prompt, { model: 'opus', effort: 'high' })`
Template — explore each area on Sonnet, then implement on Opus, pipelined so each
area starts coding as soon as its exploration lands:
```js
export const meta = {
name: "fable-tackle",
description:
"Explore on Sonnet 5, implement on Opus 5.5, orchestrate on Fable 5.1",
phases: [{ title: "Explore" }, { title: "Implement" }],
};
// `args` = the list of sub-tasks/areas the orchestrator (you) carved out.
const areas = args?.areas ?? args ?? [];
const results = await pipeline(
areas,
(area) =>
agent(`Explore (read-only), reason at high effort: ${area.explore}`, {
label: `explore:${area.name}`,
phase: "Explore",
model: "sonnet",
effort: "high",
agentType: "Explore",
schema: area.exploreSchema,
}),
(findings, area) =>
agent(
`Implement, reason at high effort. Findings from exploration:\n${JSON.stringify(findings)}\n\nTask: ${area.code}`,
{
label: `code:${area.name}`,
phase: "Implement",
model: "opus",
effort: "high",
},
),
);
return results.filter(Boolean);
```
You (Fable) decide areas before calling Workflow, and you review/verify the
returned work after — that decomposition and review is the orchestration phase.
### Quick / single-step tasks → use the Agent tool
For a one-shot explore or one-shot edit, spawn a single subagent:
- Explore: `Agent(subagent_type: "Explore", model: "sonnet", prompt: "...")`
- Code: `Agent(model: "opus", prompt: "...")`
The Agent tool has _no_ thinking/effort parameter, so a subagent inherits the
session's effort. To still get "high thinking," put an explicit cue in the
subagent prompt — e.g. _"Reason at high effort; think carefully step by step
before answering."_ If precise high-effort control matters, prefer the Workflow
route above.
## The loop
1. _Orchestrate (Fable 5.1):_ break the task into exploration questions and
implementation steps.
2. _Explore (Sonnet 5, high):_ delegate the read-only investigation. Use the
Explore agent type so this pass locates and reads code but never edits it.
3. _Implement (Opus 5.5, high):_ delegate the code changes, feeding in the
exploration findings so Opus doesn't re-discover them.
4. _Verify (Sonnet 5, high):_ when the change is visual or UI-facing, delegate
the screenshot / preview-driving / rendered-UI check to a Sonnet 5 subagent —
it reads images and screenshots well. Non-visual verification (running tests,
reading logs) can stay with the orchestrator.
5. _Orchestrate (Fable 5.1):_ integrate, review for correctness, fold in the
verification results, and decide whether another explore→code→verify loop is
needed.
Keep exploration and coding cleanly separated — the exploration pass is what lets
the Opus coding pass stay focused on writing correct code instead of hunting for
context.