Fable 5 for GTM and SaaS: The Complete Skills and Workflows Playbook

Sources:

• GitHub: oliwoodman/fable-skills (5 skills Fable 5 wrote before it left standard plans in July 2026: security sweep, project setup, build planner, honest advisor, bug hunter)
• Claude Code for GTM lead mag (6 workflows: list building, enrichment, CRM cleanup, personalisation, competitive intel, signal processing)
• Claude Cowork for LinkedIn lead mag (7 LinkedIn skills, scheduling, lead qualification, DM strategy)
• Claude Code for B2B Cold Email lead mag (full outbound pipeline, personalisation waterfall, reverse lead magnet)
• 60 Claude Code Agents for Marketing, GTM, and Growth lead mag (35 agents across 7 categories)
• Claude Design 2.0 lead mag (design systems, templates, animations, design skills for Claude Code)

Claude Fable 5 was Anthropic's frontier model, included on standard plans for a final weekend in July 2026. The best way to use that window was to have Fable write skills: files where the model documents exactly how it does a job, so every model that follows can execute it the same way.

This playbook combines:

1. The five skills Fable wrote for itself before leaving (security, setup, planning, advising, debugging)
2. The GTM, marketing, and SaaS workflows from the existing Conigma lead mag library that run best on Fable 5
3. How to commission your own skills using Fable's own method

What makes Fable 5 different for this work

Fable 5 (Claude Opus 4.8) is Anthropic's best reasoning model. For GTM and SaaS work, this distinction matters in specific situations:

Use Fable / Opus 4.8 when:

• The task requires genuine judgment, not just pattern matching (is this a good business idea, does this architecture hold, what is the real reason this deal was lost)
• You are writing a skill or CLAUDE.md that will run on cheaper models later (the smart model thinks once, the cheaper model executes many times)
• The task involves weighing trade-offs with incomplete information (build vs buy, which ICP to prioritise, how to price)
• You are doing the planning pass before a large execution task

Use Sonnet (cheaper, faster) when:

• Executing a plan that has already been thought through
• Bulk processing: enrichment, personalisation at scale, CRM cleanup
• Drafting from a clear brief with good context
• Any task where the skill already exists and Fable already wrote the method

The pattern Fable itself documented: the smart model thinks once and writes the skill. The cheaper model follows it forever after. This is the core operating principle behind all five Fable skills.

Source: github.com/oliwoodman/fable-skills

Five skills Fable 5 wrote in its own structure before leaving standard plans. Each follows the same format: when it triggers, the one rule, the method, the standards, the output, the honest limits.

Install all five in one paste:

One-paste install

Paste this into Claude Code in any project:

Please install the five skills from this repo:
https://github.com/oliwoodman/fable-skills

Copy each skill folder (security-sweep, project-setup, build-planner,
honest-advisor, bug-hunter) into this project's .claude/skills/ directory.
If I already have a skill with the same name, show me the difference and ask
before touching it. When you're done, list what you installed and give me one
example of a sentence that would trigger each skill.

To install globally (available in every project, not just this one): say so before running. The skills go into ~/.claude/skills/ instead of the project-level .claude/skills/.

Skills trigger themselves from natural language. You do not need to invoke them explicitly. Say "is this safe to ship?" and the sweep runs. Say "plan this build" and the planner takes over.

The Fable skill structure

Fable designed one structure for all five skills. Every skill follows it:

1. When it triggers: the exact phrases and situations that activate this skill
2. The one rule: the single principle that governs every decision in the skill
3. The method: the step-by-step process the skill executes
4. The standards: what counts as a good output vs a bad one
5. The output: exactly what the user receives
6. The honest limits: when NOT to trust the skill

The last section is the most important one. Every skill ends by telling you when not to trust it. A skill that knows its own limits is worth ten that do not. The security sweep says it is not a penetration test. The advisor admits it will eventually cave if you argue long enough. The planner says a plan is a hypothesis.

Skill 1: Security Sweep

The job: checks everything you ship the way a security reviewer would, tuned to the holes vibe-coded apps actually get hacked through.

What you walk away with: a ranked list of what an attacker could really do, in plain English, with fixes offered worst-first.

Trigger phrases: "is this safe to ship?", "security check", "can anyone get in here?", "check for vulnerabilities"

The one rule: describe the real attack, not the category. Not "SQL injection risk" but "an attacker could extract your entire users table with this endpoint."

What it checks (tuned for vibe-coded apps, not enterprise codebases):

• Authentication gaps: can someone reach data they should not be able to reach?
• Injection vectors: SQL, command, template injection
• Secrets in code: API keys, credentials, tokens hardcoded or in .env files committed to version control
• Exposed admin routes and unprotected endpoints
• Input validation: what can a user send that the app does not expect?
• Rate limiting: can someone hammer this endpoint?
• Dependency vulnerabilities: known CVEs in the packages in use

Output format: ranked list, worst attack first. Each entry: what the attack is, what it gives the attacker, how to fix it, how long the fix takes.

Honest limit: this is not a penetration test. A real pen test involves active exploitation against a running system. The sweep reviews code and configuration. It will catch the common holes. It will miss anything that requires runtime context.

# Install
npx skills add oliwoodman/fable-skills security-sweep

# Trigger naturally
"Is this safe to ship?"
"Run a security sweep before we deploy."
"Check this codebase for anything an attacker could use."

Skill 2: Project Setup

The job: starts a new project so it does not fall apart in month two. Git, secrets management, CLAUDE.md, deployed before feature one.

What you walk away with: a live URL and foundations that make month two boring in the right way.

Trigger phrases: "start a new project", "set up this repo", "I want to build X from scratch"

The one rule: month two is when everything breaks. Set up for month two on day one.

What the skill does:

• Initialises git with a proper .gitignore
• Sets up secrets management (.env with documentation, never committed)
• Creates CLAUDE.md with project context so every future Claude session starts informed
• Chooses a deployment target and gets the project live before writing feature one
• Sets up a minimal CI pipeline so pushes do not break things silently
• Creates a README that explains what the project is and how to run it locally

Output: a structured project that a new developer (or a new Claude session) can understand and run in under 10 minutes. A live URL. A CLAUDE.md that front-loads the context every future session needs.

Honest limit: the setup is a starting structure, not a guarantee of good architecture. The decisions made in week one (database choice, auth approach, deployment target) will constrain month six. The skill gets you started correctly. It does not design the system.

# Trigger naturally
"Start a new project. I want to build [DESCRIBE WHAT IT IS]."
"Set up this repo properly before we start building."
"Get this deployed first, then we can start on features."

Skill 3: Build Planner

The job: turns "I want to build X" into a staged plan a cheaper model can execute. The smart model thinks once.

What you walk away with: a PLAN.md where every step carries its own verification. You know the plan worked because each step proves itself before the next one starts.

Trigger phrases: "plan this build", "how would you approach building X?", "break this down before we start"

The one rule: a plan is a hypothesis. Write it so it can be wrong.

What the skill does:

• Asks clarifying questions before planning (the questions a contractor would ask before quoting)
• Breaks the build into stages, not tasks (stages are chunks that deliver something testable)
• For each stage: what gets built, what the acceptance criteria are, what a cheaper model needs to know to execute it
• Flags the riskiest assumption in the plan and proposes the cheapest test that could kill it
• Writes a PLAN.md in the project folder

Output: PLAN.md with: goal, assumptions, stages (each with acceptance criteria), the one riskiest assumption, and the cheapest test that could invalidate the whole plan.

For GTM and SaaS use: use the build planner before any significant Claude Code outbound campaign, lead magnet build, or product feature. Have Fable plan it. Have Sonnet execute it.

Honest limit: a plan is a hypothesis. The skill will plan a thing you should not build. It does not know your market, your competitors, or your customers. It will write a good plan for a bad idea. That is what the honest advisor is for.

# Trigger naturally
"Plan this build before we start."
"I want to build [DESCRIBE]. Break it down for me."
"Write a PLAN.md for this project."

# For GTM use:
"Plan the build for a lead qualification agent.
I want it to enrich inbound leads via Apollo, score them against my ICP,
draft a personalised email per lead, and queue for human review before sending.
Write PLAN.md."

Skill 4: Honest Advisor

The job: stress-tests your business idea with the yes-man switched off.

What you walk away with: a straight verdict, the one number your idea hangs on, and the cheapest test that could kill it.

Trigger phrases: "be honest with me", "stress-test this", "what's the real problem with this idea?", "am I missing something?"

The one rule: find the number the idea lives or dies on. Every business idea has one. Surface it.

What the skill does:

• Asks what the idea is and what success looks like
• Identifies the one assumption the whole thing depends on (the number, the behaviour, the market condition)
• Gives a straight verdict: this works if X is true, it does not work if X is false
• Names the cheapest test that could answer the question before you build anything
• Does not caveat everything. Makes a call.

Output: the verdict (works / does not work / depends on one thing), the one number or assumption it hangs on, the cheapest test that could kill it, and what the test would cost in time and money.

For GTM and SaaS use: run this before committing to a new ICP, a new channel, a new product feature, or a new outbound approach. Have Fable stress-test it before you build the campaign.

Honest limit: the skill admits it will eventually cave if you argue long enough. If you tell it the idea is great and you are sure, it will start finding reasons to agree. The value is in the first unprompted verdict, before you push back. Ask once. Take that answer seriously.

# Trigger naturally
"Be honest with me about this idea: [DESCRIBE]"
"Stress-test this before I commit to building it."
"What's the one thing that could kill this?"

# For GTM use:
"Be honest with me about this outbound strategy.
We are planning to cold email 500 agencies per week offering a content audit.
What is the one number this whole thing lives or dies on?
What is the cheapest test we could run this week to find out if it works?"

Skill 5: Bug Hunter

The job: hunts a bug the way a senior debugger would. Reproduce first, cause not symptom, prove the fix.

What you walk away with: the bug actually fixed, with proof the failing case now passes. No more "should be fixed now."

Trigger phrases: "this is broken", "debug this", "I can't figure out why X isn't working"

The one rule: prove you can reproduce it before you touch anything.

What the skill does:

• Step 1: reproduce the bug in a minimal case. No guessing at fixes before the bug is reproducible.
• Step 2: identify the cause, not just the symptom. The error message is the symptom. The cause is why the error is happening.
• Step 3: propose the fix and explain why it addresses the cause, not just the symptom
• Step 4: prove the fix works by showing the failing case now passes
• Step 5: check whether the same root cause exists elsewhere in the codebase

Output: the bug fixed, the cause documented, and a check of whether the same pattern exists elsewhere.

Honest limit: the skill is good at bugs that are reproducible. Intermittent bugs (race conditions, bugs that only appear under load, bugs that depend on external state) are harder. The skill will still try to help but may not find the root cause without more information about when the bug appears.

# Trigger naturally
"This is broken. [DESCRIBE WHAT IS HAPPENING]"
"Debug this for me."
"I can't figure out why [X] isn't working."

How to commission a skill for any job you repeat. The Fable method: have the smartest model available interview you about the job, watch you do it, and write the manual in the same format as the five Fable skills.

The commission prompt

From COMMISSION-PROMPT.md in the fable-skills repo. Paste this into a session with the smartest model you have access to:

I want you to write a skill in the Fable format for a job I repeat.

The Fable skill format is:
1. WHEN IT TRIGGERS: exact phrases and situations that activate this skill
2. THE ONE RULE: the single principle that governs every decision
3. THE METHOD: step-by-step process the skill executes
4. THE STANDARDS: what counts as a good output vs a bad one
5. THE OUTPUT: exactly what the user receives
6. THE HONEST LIMITS: when NOT to trust this skill

Before writing anything:
- Ask me what the job is
- Ask me to show you or describe an example of me doing it well
- Ask me what goes wrong when it's done badly
- Ask me what the output should look like
- Ask me when you should not attempt this job

Only after getting those answers: write the skill in the exact Fable format above.
Save it as SKILL.md in a folder named [job-name] in .claude/skills/.

The most important section is the honest limits. The skill must tell the user
when not to trust it. Do not skip this.

The principle: any time the smartest model does a job exactly how you want it done, make it write the skill before the session ends. The model goes back. The manual stays yours.

GTM skills worth commissioning for your own use

These are the recurring GTM jobs that most benefit from having Fable write the skill once:

ICP qualification skill: your specific qualification criteria, your hot/warm/cold definitions, your disqualifiers. Fable writes it based on your actual deals. Every future lead gets scored the same way.

Cold email copywriting skill: your voice, your banned phrases, your CTA preferences, your copy rules. Replaces the copy brief you write from scratch every campaign.

Competitive positioning skill: how you frame against each main competitor, what to say when their name comes up, which G2 complaints to reference, what your defensible advantage is.

Content repurposing skill: your voice, your formats, which content types to produce from which source material, what to never do. Replaces the brand brief you repeat to Cowork every session.

Lead magnet brief skill: how you decide what to build, what makes a good lead magnet angle for your ICP, what the structure should look like, what to avoid.

For each: have a session with Fable where you show it an example of you doing the job well. Have it ask questions. Then commission the skill before the session ends.

Sources: Claude Code Workflows for GTM lead mag + Claude Code for B2B Cold Email lead mag

The GTM workflows from the existing library that run best on Fable 5 because they require genuine judgment rather than pattern execution.

When to use Fable vs Sonnet for outbound

Task	Model
Writing the personalisation waterfall logic	Fable (judges which signals matter most)
Executing the waterfall across 200 leads	Sonnet (following a defined process)
Writing the copy skill for cold email	Fable (encodes best practice once)
Running the copy skill to generate 50 emails	Sonnet (executes the skill)
Defining ICP criteria and scoring rules	Fable (requires judgment on edge cases)
Scoring leads against defined ICP criteria	Sonnet (applies defined rules)
Stress-testing whether a new ICP is viable	Fable (honest advisor skill)
Building the list from a confirmed ICP	Sonnet (Prospeo API queries)
Planning a new outbound campaign architecture	Fable (build planner skill)
Executing the campaign build from PLAN.md	Sonnet (following the plan)

Fable-specific outbound prompts

# Have Fable write your personalisation waterfall (run once, use forever)
"I run outbound for [DESCRIBE OFFER AND ICP].
I want to build a personalisation waterfall that checks signals in priority order:
hiring signals, client roster signals, tech stack signals, company bio signals, fallback.

Before writing anything:
- Ask me which signals have actually converted for us in the past
- Ask me which signals have produced bad-fit replies
- Ask me what the fallback should do when no good signal exists

Then write the waterfall as a SKILL.md in the Fable format.
Save it to .claude/skills/personalisation-waterfall/SKILL.md"

# Have Fable write your copy skill
"I want you to write a cold email copy skill in the Fable format.

Before writing:
- Read my best-performing emails from the past 6 months in [FOLDER]
- Ask me what makes the best ones work
- Ask me what we never say and what we always say
- Ask me what the QA checklist should be

Then write the skill as SKILL.md in .claude/skills/cold-email-copy/"

# Have Fable stress-test a new outbound approach (honest advisor skill)
"Be honest with me about this outbound approach:
[DESCRIBE THE CAMPAIGN: ICP, OFFER, CHANNEL, VOLUME, EXPECTED REPLY RATE]

What is the one number this lives or dies on?
What is the cheapest test we could run this week to find out if it works
before we commit to the full build?"

Sources: Claude for Marketing lead mag + LinkedIn in 2026 lead mag + Claude Cowork for LinkedIn lead mag

Fable's role in marketing is the same as in outbound: think once, write the skill, have cheaper models execute forever after.

Where Fable adds the most leverage in marketing

Competitive intelligence: the Monday brief is assembly work (Sonnet or Cowork). But interpreting what a competitor's pricing change actually means for your positioning requires judgment. Have Fable read the brief and give you the so-what before you forward it.

"Read this competitive brief: [PASTE BRIEF]
Apply the honest advisor skill.
What does this actually mean for our positioning?
What is the one thing we should do differently this week based on this?
Do not just describe the changes. Tell me what to do."

Content strategy: Sonnet can repurpose content. Fable can tell you which content is actually worth making, which angles will land with your ICP, and which posts are wasting effort.

"Read my last 10 LinkedIn posts from [FOLDER].
Be honest with me: which of these are genuinely worth making for my ICP
and which are just filling the calendar?
What one content direction should I double down on and which should I stop?"

Brand voice skill: the content repurposing that Cowork does is only as good as the brand voice skill it follows. Have Fable write that skill properly, not you.

"I want you to write a brand voice skill in the Fable format for my content.

Before writing:
- Read these 5 posts that I think represent my voice perfectly: [PASTE]
- Ask me what the posts have in common
- Ask me what I would never say and what I always say
- Ask me how I write differently for LinkedIn vs email vs Slack

Then write the skill as .claude/skills/brand-voice/SKILL.md
This skill will be used by Cowork on every content and repurposing task."

Fable for LinkedIn content quality

Fable understands the 2026 LinkedIn quality problem: AI slop is flooding the timeline. The content that cuts through has a narrative, data, or physical moat. Fable can audit your content and tell you which posts have it and which do not.

# Content quality audit (honest advisor)
"Read this LinkedIn post: [PASTE POST]

Apply the following filter:
1. Is there a narrative, data, or physical moat in this content?
2. Could this exact post have been written by someone who entered my topic into Claude?
3. Is there at least one specific detail (a name, a number, a quote, a date) that only I could have included?

Be direct. If it fails these checks, tell me what to add to fix it.
Do not soften the verdict."

# Hook writing with Fable
"I am writing a LinkedIn post about [TOPIC] for [ICP].
The hook has to earn the See More click in 2 lines.
Give me 5 hook options using these mechanisms:
- Curiosity gap
- Contrarian claim
- Specific number that implies real data follows
- Pain recognition
- Stakes escalation
For each: explain why it works and what the risk is if it fails.
Then tell me which one you would use and why."

Sources: Claude Design 2.0 lead mag + 60 Claude Code Agents lead mag

Fable's judgment is most valuable in product and SaaS work at the planning and architecture stage. Execution follows from good planning. Bad planning is expensive to undo.

Fable for SaaS product decisions

Use the honest advisor skill before building anything new:

# Before building a new feature
"Be honest with me about this feature idea: [DESCRIBE]
Who actually wants this? Is it the ICP or is it one loud customer?
What is the one metric that will tell us in 30 days whether it was worth building?
What is the cheapest version we could ship that tests the core assumption?"

# Before choosing a technical approach
"I need to choose between [APPROACH A] and [APPROACH B] for [DESCRIBE THE PROBLEM].
Do not give me a balanced comparison. Make a call.
What would you build and why?
What would you tell me in 6 months that I should know today?"

# Pricing decision
"I need to decide on pricing for [DESCRIBE PRODUCT].
Be honest with me: am I underpricing, overpricing, or pricing for the wrong metric?
What is the one pricing model change that would most improve our NRR?
What data would you want before making this call?"

Fable with the build planner for SaaS features

# Full SaaS feature build flow

# Step 1: Honest advisor (Fable)
"Be honest with me about building [FEATURE].
What is the one assumption it relies on?
What is the cheapest test before we write a line of code?"

# Step 2: If the idea survives: Build planner (Fable)
"Plan the build for [FEATURE].
Break it into stages where each stage delivers something testable.
Include acceptance criteria per stage.
Flag the riskiest technical assumption in the plan.
Write PLAN.md."

# Step 3: Security sweep before deploy (Fable or Sonnet)
"Is this safe to ship?"

# Step 4: Execution (Sonnet, following PLAN.md)
"Execute Stage 1 from PLAN.md."

Design decisions: use Fable with the Anthropic frontend design skill or UIUX Pro Max for any UI where the design matters to the product. Fable commits to a direction and reasons through it. Sonnet executes within that direction.

"I need to design [DESCRIBE THE UI: what it is, who uses it, what they do in it].
Before generating anything:
- Tell me what design direction you would commit to and why
- Tell me what the 3 most common AI slop choices are for this type of UI
- Tell me which of those you are going to actively avoid
Then build it."

Fable with Claude Code agents for GTM

Fable (Opus 4.8) is the model for the agents that require the most judgment. From the 60 Claude Code Agents lead mag:

Use Opus for:

• @product-strategist (build/cut/defer decisions, tied to NRR)
• @multi-agent-coordinator (orchestrates parallel agents, synthesises results)
• @workflow-orchestrator (DAG execution, handles failures, reports progress)
• @innovation-lab (prototypes new capabilities, evaluates whether to build or abandon)
• @prompt-engineer (optimises prompts for qualification, personalisation, signal classification)

Copy-paste multi-agent GTM build using Fable as coordinator:

@multi-agent-coordinator Run a full campaign build for [PRODUCT / OFFER]:
- @market-analyst: map competitor positioning and find our unfair advantage
- @landing-page-optimizer: write the launch page copy (3 headline variants)
- @email-automator: build the 5-touch cold email sequence for [ICP]
- @analytics-engineer: define the 5 metrics that will tell us if this is working
Run in parallel. Synthesise into a single campaign brief.
Model for this orchestration: claude-opus-4-8

All Fable-specific prompts in one place.

Install and commission

# Install all 5 Fable skills
"Please install the five skills from https://github.com/oliwoodman/fable-skills
Copy each skill folder into .claude/skills/. Show me what you installed
and one trigger sentence per skill."

# Commission a new skill
"I want you to write a skill in the Fable format for [JOB I REPEAT].
Before writing: ask me what the job is, show me an example of doing it well,
what goes wrong when done badly, what the output looks like, when not to attempt it.
Write it as SKILL.md in .claude/skills/[job-name]/
Most important: do not skip the honest limits section."

5 Fable skills quick reference

# Security sweep
"Is this safe to ship?"
"Run a security sweep before we deploy."
# Output: ranked list of real attacks, worst first, with fixes

# Project setup
"Start a new project. I want to build [X]."
"Set up this repo properly before we start building."
# Output: live URL, CLAUDE.md, git, secrets, CI, README

# Build planner
"Plan this build before we start."
"Write a PLAN.md for [PROJECT]."
# Output: PLAN.md with stages, acceptance criteria, riskiest assumption, cheapest test

# Honest advisor
"Be honest with me about [IDEA]."
"Stress-test this before I commit."
# Output: verdict, the one number it hangs on, cheapest test that could kill it

# Bug hunter
"This is broken. [DESCRIBE]"
"Debug this for me."
# Output: bug fixed, cause documented, same pattern checked elsewhere

Fable for GTM quick reference

# Stress-test a campaign idea (honest advisor)
"Be honest with me about this outbound strategy: [DESCRIBE]
What is the one number this lives or dies on?
What is the cheapest test to run this week?"

# Plan a campaign build (build planner)
"Plan the build for [CAMPAIGN TYPE].
Break into stages with acceptance criteria.
Flag the riskiest assumption. Write PLAN.md."

# Write a personalisation waterfall skill
"Interview me about how we personalise cold emails.
Watch how I define signals. Ask what has converted vs produced bad replies.
Write the waterfall as a Fable skill in .claude/skills/personalisation-waterfall/"

# Write a copy skill
"Read my best-performing emails from [FOLDER].
Ask me what makes the best ones work and what we never say.
Write the cold email copy skill in the Fable format."

# Interpret a competitive brief (honest advisor + competitive)
"Read this brief: [PASTE]
What does this actually mean for our positioning?
What is the one thing to do differently this week? Make a call."

# LinkedIn content quality audit
"Read this post: [PASTE]
Apply the narrative/data/physical moat filter.
If it fails, tell me what to add. Do not soften the verdict."

# Multi-agent campaign build (Opus as coordinator)
"@multi-agent-coordinator Build a full campaign:
- @market-analyst: competitive positioning
- @landing-page-optimizer: 3 headline variants
- @email-automator: 5-touch sequence for [ICP]
- @analytics-engineer: 5 success metrics
Model: claude-opus-4-8"

# Product feature decision (honest advisor)
"Be honest with me about building [FEATURE].
What is the one assumption it relies on?
What is the cheapest test before we write a line of code?"

# Design quality (prevents AI slop)
"What design direction would you commit to for [UI DESCRIBE]?
What are the 3 most common AI slop choices for this type of UI?
Which are you going to avoid? Then build it."

Model routing for all workflows

# Use Fable (Opus 4.8) for:
- Writing skills (all 5 Fable skills, commissioning your own)
- Honest advisor calls (stress-testing ideas before committing)
- Build planning (PLAN.md before any significant build)
- Security sweeps (final check before shipping)
- Multi-agent orchestration (@multi-agent-coordinator, @workflow-orchestrator)
- Product strategy (@product-strategist)
- Prompt engineering (@prompt-engineer)
- Innovation evaluation (@innovation-lab)
- Any decision that requires weighing trade-offs with incomplete information

# Use Sonnet for:
- Executing any plan that Fable already wrote
- Bulk processing: enrichment, CRM cleanup, personalisation at scale
- Cold email copy generation (from a copy skill Fable wrote)
- Lead scoring (against criteria Fable defined)
- Competitive brief assembly (Cowork scheduled task)
- Performance reporting (Cowork Friday report)
- Content repurposing (against a brand voice skill Fable wrote)
- All 60 Claude Code Agents except the 5 Opus ones

# Use Haiku for:
- Sub-agent data gathering inside multi-agent workflows
- Signal classification at scale (cheap, fast, defined rules)
- Batch formatting and normalisation