Fable Method: Claude 5 Workflows naar Herbruikbare AI Skills

De meeste teams verspillen Claude Fable 5 door de outputs te kopiëren in plaats van het denkproces vast te leggen. De echte waarde zit niet in wat Fable produceert - maar in hoe het problemen doordenkt. Het patroon dat loont: trek die redenering om tot herbruikbare vaardigheden die u kunt draaien op goedkopere modellen.

Wat Fable Workflows Anders Maakt

Fable 5 voltooit niet alleen taken. Het verdeelt werk in fasen, plaatst duidelijke controlepunten ertussen, behandelt fouten met specifieke herstelroutes, en valideert resultaten voordat het iets "klaar" noemt. Het goede nieuws is dat dit gedrag zichtbaar is, wat betekent dat u het kunt vastleggen.

Wat u hergebruikt is geen gekopieerde systeemprompt of slimme instructieset. Het is een gedragsworkflow gecodeerd als SKILL.md bestand. Die vaardigheid definieert het contract tussen intentie en verificatie - de fasen, de poorten, de controles - zonder u vast te pinnen aan een specifiek model.

textCopy
# Skill: Code Review Workflow

## Phases

1. UNDERSTAND: Parse PR context, identify changed files, note dependencies
2. ANALYZE: Check each file against project conventions, flag patterns
3. VERIFY: Run static analysis, confirm test coverage, validate types
4. SYNTHESIZE: Compile findings into prioritized feedback

## Phase Gates

- UNDERSTAND → ANALYZE: Must list all affected modules
- ANALYZE → VERIFY: Must document at least one observation per file
- VERIFY → SYNTHESIZE: All automated checks must complete

## Error Recovery

- Missing context: Request specific files before proceeding
- Ambiguous convention: Flag for human decision, continue with assumption noted
- Tool failure: Retry once, then proceed with manual equivalent

De Phase Gates sectie is waar de echte waarde vaak naar boven komt. Zonder expliciete poorten kan een model van "understand" direct naar "synthesize" springen en stilletjes verificatie overslaan. Fable pauzeert natuurlijk voor deze controlepunten; goedkopere modellen hebben ze meestal expliciet nodig.

De error recovery sectie houdt de workflow in beweging wanneer de realiteit rommelig wordt. In plaats van vastlopen of stilletjes falen, vertelt de vaardigheid het model precies hoe door te gaan.

Vaardigheden Extraheren uit Fable Sessies

Vaardighedenextractie werkt het beste met een verse Fable sessie en een representatieve taak. Begin niet met uw lastigste project. Kies iets dat de workflow oefent die u wilt vastleggen zonder begraven te worden in domeindetails.

textCopy
You are about to complete a task. Before executing, expose your complete reasoning process:

1. What phases will you work through?
2. What conditions must be met before moving between phases?
3. What verification steps will you perform?
4. How will you handle errors or ambiguity?
5. What does "done" look like?

Task: [YOUR REPRESENTATIVE TASK]

Do not execute yet. Only describe your intended approach.

Fable retourneert een gedetailleerd plan. Dat plan is het ruwe materiaal voor uw vaardigheid. Wat vaak gemist wordt: vragen naar de aanpak voor uitvoering is de hele truc. Zodra het model begint met het werk, wordt de redenering geïmpliceerd en moeilijker schoon te extraheren.

Converteer vervolgens het plan naar een draagbare vaardigheid:

textCopy
Convert your approach into a reusable SKILL.md with these sections:
- Phases (numbered, with clear entry/exit criteria)
- Phase Gates (explicit conditions for progression)
- Verification Checks (specific tests, not vague quality statements)
- Error Recovery (concrete actions for common failure modes)
- Completion Criteria (measurable, not subjective)

The skill should be model-agnostic - assume the executing model needs explicit guidance.

Die laatste regel is belangrijker dan het lijkt. Fable kan wegkomen met korte instructies omdat het gaten opvult met sterke impliciete redenering. Opus, Sonnet en Haiku hebben doorgaans expliciete ondersteuning nodig. In de meeste gevallen is het beter dat de vaardigheid te veel specificeert dan dat het capaciteit aanneemt.

Globale en Projectspecifieke Vaardigheden Scheiden

De Fable to Opus Skill Bridge aanpak splitst vaardigheden in twee lagen. Globale workflow vaardigheden leggen algemene planningsgewoonten vast - hoe code review te doen, hoe een refactor te structureren, hoe een bug te onderzoeken. Projectspecifieke vaardigheden leggen lokale conventies vast - deze repo gebruikt Prettier, tests leven in __tests__, deploy vereist goedkeuring.

yamlCopy
# global-skills/code-review.yaml
name: Code Review Workflow
applies_to: any_codebase
phases:
  - understand_context
  - analyze_changes
  - verify_quality
  - synthesize_feedback

# project-skills/acme-api.yaml
name: ACME API Conventions
applies_to: acme-api
conventions:
  testing: Jest with 80% coverage minimum
  formatting: Prettier with project config
  commits: Conventional commits required
  deployment: Requires CODEOWNER approval

Deze twee lagen verouderen met verschillende snelheden. Uw code review workflow kan jaren stabiel blijven. Uw projectconventies veranderen wanneer dependencies, tooling of beleid verandert. Door ze te splitsen kunt u de ene updaten zonder de andere te verstoren.

Parallelle Subagent Workflows Bouwen

Eenvoudige vaardigheden zijn prima voor lineaire taken. Zodra werk groot wordt, begint parallellisme ertoe te doen. De Maestro aanpak documenteert fan-out, verify en synthesize patronen.

pythonCopy
# orchestrator.py
import asyncio
from typing import List
from claude_client import ClaudeClient

async def parallel_analysis(files: List[str], skill: str) -> dict:
    """Fan out analysis to parallel subagents, then synthesize."""
    client = ClaudeClient(model="claude-sonnet")
    
    # Fan-out phase: spawn subagent per file
    tasks = [
        client.complete(
            system=skill,
            prompt=f"Analyze this file:\n\n{read_file(f)}"
        )
        for f in files
    ]
    results = await asyncio.gather(*tasks)
    
    # Verify phase: fresh context catches groupthink
    verification = await client.complete(
        system="You are a skeptical reviewer. Find flaws in this analysis.",
        prompt=f"Analysis results:\n\n{format_results(results)}"
    )
    
    # Synthesize phase: combine verified results
    synthesis = await client.complete(
        system=skill,
        prompt=f"""
        Original analyses: {results}
        Verification critique: {verification}
        Synthesize a final report that addresses the critique.
        """
    )
    
    return synthesis

De verificatiestap gebruikt een verse context met een weerleg-standaard prompt. Dat voorkomt dat de synthesizer goedkeurt wat de parallelle agents ook zeiden. Een reviewer die sceptisch begint vangt meestal fouten die een voortzetting van dezelfde context zou missen.

asyncio.gather draait bestandsanalyses tegelijkertijd, wat de kloktijd flink kan verkorten bij grote changesets.

Bestandsgebaseerde Context Handoffs

Lange workflows raken contextlimieten. Bestandsgebaseerde handoffs lossen dat op door tussentijdse staat naar schijf te schrijven, dan alleen te laden wat de volgende fase echt nodig heeft.

pythonCopy
# handoff.py
import json
from pathlib import Path

def save_phase_output(phase: str, data: dict, session_id: str):
    """Persist phase output for next agent."""
    output_dir = Path(f".claude/sessions/{session_id}")
    output_dir.mkdir(parents=True, exist_ok=True)
    
    (output_dir / f"{phase}.json").write_text(
        json.dumps(data, indent=2)
    )

def load_phase_context(phases: list[str], session_id: str) -> str:
    """Load only the phases needed for current work."""
    output_dir = Path(f".claude/sessions/{session_id}")
    context_parts = []
    
    for phase in phases:
        phase_file = output_dir / f"{phase}.json"
        if phase_file.exists:
            data = json.loads(phase_file.read_text)
            context_parts.append(f"## {phase.upper} OUTPUT\n{json.dumps(data, indent=2)}")
    
    return "\n\n".join(context_parts)

De vaardigheid spelt vervolgens uit welke eerdere fasen elke nieuwe fase moet inladen:

yamlCopy
phases:
  understand:
    outputs: [file_list, dependency_graph, change_summary]
  analyze:
    requires: [understand]
    outputs: [findings, risk_assessment]
  verify:
    requires: [analyze]  # doesn't need understand
    outputs: [verification_results]
  synthesize:
    requires: [analyze, verify]  # skips understand
    outputs: [final_report]

Selectief laden houdt elke fase gefocust. De synthesize fase heeft de ruwe bestandslijst van understand niet nodig - het heeft de bevindingen en verificatieresultaten nodig. Kleinere context betekent meestal helderder redeneren en lagere kosten.

Validatie: De Lijn Tussen Nuttig en Cargo Cult

Een Reddit discussie over prompt distillatie trok scherpe kritiek voor vage instructies zoals "maak geen fouten" en "wees intelligent." Die zijn niet testbaar. Het is wishful thinking verkleed als engineering.

Vaardigheden die standhouden bevatten validatie die u daadwerkelijk kunt meten:

yamlCopy
# SLECHT: Niet testbaar
verification:
  - Ensure high quality
  - Make no mistakes
  - Be thorough

# GOED: Testbaar
verification:
  - All functions have docstrings (check: grep -L '"""' *.py)
  - Test coverage exceeds 80% (check: pytest --cov --cov-fail-under=80)
  - No type errors (check: mypy --strict)
  - Linter passes (check: ruff check.)

De Claude Fable 5 Clone repository verpakt 12 evaluatiecases met zijn vaardigheidsdefinities. Elke case bevat een input, verwacht gedrag en slaag/faal criteria. Dat verandert "voelt het goed" in "slaagt het voor de tests."

pythonCopy
## eval_cases/code_review_01.py
EVAL_CASE = {
    "name": "Catches missing error handling",
    "input": """
def fetch_user(id):
    response = requests.get(f"/users/{id}")
    return response.json
    """,
    "expected_findings": [
        "missing_error_handling",
        "no_timeout_specified"
    ],
    "pass_criteria": lambda findings: all(
        expected in findings
        for expected in ["missing_error_handling", "no_timeout_specified"]
    )
}

Draai uw vaardigheid tegen evaluatiecases voor deployment. Draai ze opnieuw na elke vaardigheidswijziging. Zo worden regressies vroeg gevangen, en zo bewijst u dat de vaardigheid echt werk doet.

Kostenoptimalisatiestrategie

Met Anthropic's promotie eindigend 19 juli, moeten teams strategisch zijn over Fable gebruik. De aanpak die werkt: gebruik Fable voor vaardighedenextractie en verbetering, draai vervolgens de resulterende vaardigheden op goedkopere modellen.

Denk aan de vaardigheid als een krachtmultiplier. Leg Fable's redenering eenmaal vast, en het kan honderden Sonnet runs begeleiden. De voorafgaande extractie-inspanning blijft dividenden opleveren.

Voor teams die bouwen op Claude Code, pluggen vaardigheden direct in de agent workflow. Zie onze Claude Code Best Practices 2026 + CLAUDE.md Guide voor configuratiepatronen die goed paren met vaardigheidsgebaseerde workflows.

Veelgemaakte Extractiefouten

Outputs kopiëren in plaats van proces. Als uw vaardigheid zegt "schrijf code zoals dit voorbeeld," heeft u een artefact vastgelegd, geen workflow. Vaardigheden moeten definiëren hoe problemen aan te pakken, niet hoe een specifieke oplossing eruitziet.

De verificatiefase overslaan. Fable's interne verificatie verschijnt niet tenzij u erom vraagt. Sla de "hoe ziet klaar eruit" vraag in de extractieprompt niet over.

Over-fitten op één taak. Een vaardigheid getrokken uit één complexe taak bakt vaak domeindetails in die niet generaliseren. Extraheer uit 3-5 representatieve taken, houd dan wat consistent blijft.

Modelequivalentie aannemen. Een vaardigheid die werkt met korte instructies op Fable kan uit elkaar vallen op Sonnet. Test op uw doelmodel voordat u het uitrolt.

textCopy
## Testing skill portability

for model in [claude-fable-5, claude-opus, claude-sonnet, claude-haiku]:
    results = run_eval_suite(skill, model)
    print(f"{model}: {results.pass_rate}%")

# Typical output:
## claude-fable-5: 100%
## claude-opus: 95%
## claude-sonnet: 87%
## claude-haiku: 72%

Dat Haiku nummer is misschien prima voor hoog-volume, lage-inzet werk. Het is waarschijnlijk niet prima voor productie code review. De eval suite maakt die drempels duidelijk.

Een Vaardighedenbibliotheek Bouwen

Na verloop van tijd worden geëxtraheerde vaardigheden een bibliotheek. Structuur is belangrijk, omdat toekomstige-u (en de rest van uw team) dingen snel moet kunnen vinden.

textCopy
.claude/
├── skills/
│   ├── global/
│   │   ├── code-review.yaml
│   │   ├── refactoring.yaml
│   │   ├── bug-investigation.yaml
│   │   └── documentation.yaml
│   └── project/
│       └── conventions.yaml
├── evals/
│   ├── code-review/
│   │   ├── case_01.py
│   │   ├── case_02.py
│   │   └── case_03.py
│   └── refactoring/
│       └── case_01.py
└── sessions/
    └── [session_id]/
        ├── understand.json
        ├── analyze.json
        └── verify.json

Versiebeheer de vaardigheden. Review wijzigingen aan vaardigheden zoals u codewijzigingen reviewt. Een kapotte vaardigheid kan meer schade aanrichten dan een kapotte functie omdat het elke taak beïnvloedt die ervan afhangt.

Praktische Stappen

Begin hier (uw eerste stap)
Kies één repetitieve taak die u wekelijks doet. Open een verse Fable sessie en gebruik de extractieprompt om de aanpak vast te leggen.

Snelle winst (directe impact)

• Converteer de geëxtraheerde aanpak naar een SKILL.md bestand en test het op Sonnet
• Voeg twee meetbare verificatiecontroles toe aan uw eerste vaardigheid

Diepgaand (voor wie meer wil)

• Bouw een eval suite met 5+ testcases voor uw meest gebruikte vaardigheid
• Implementeer bestandsgebaseerde handoffs voor workflows die contextlimieten overschrijden

Nuttige Bronnen

• Fable to Opus Skill Bridge - Twee-prompt extractiemethode met globale/project vaardigheidsscheiding
• Maestro Skills - Parallelle subagent patronen en verse-context verificatieworkflows
• Claude Fable 5 Clone - Complete vaardigheidsverpakking met evaluatiecases
• Claude Fable 5 Plan Details - Officiële toegangslagen en gebruikscrediet informatie

Slotgedachten

De Fable Methode gaat niet over het klonen van een model's intelligentie. Het gaat over het vastleggen van een observeerbaar proces en het draagbaar maken. Geëxtraheerde vaardigheden dragen de systematische aanpak over - fasen, poorten, verificatie, foutherstel - naar modellen die deze patronen niet betrouwbaar zelf afleiden.

Teams die de meeste waarde uit Fable halen draaien het niet op elke taak. Ze gebruiken het waar het ertoe doet: extraheer eenmaal, voer vele keren uit op goedkopere modellen, en verfijn wanneer de eval suite drift toont. Met het promotievenster gesloten, is dat ook de aanpak die financieel zinvol is.

Begin met één workflow. Extraheer het schoon. Valideer het met echte controles. Schaal dan van daaruit.