--- 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.