fable

name

fable

description

Turn a concept, domain, or idea into a memorable fable (寓言) — a concrete allegorical story (situation → characters → conflict → resolution → moral) whose moral maps faithfully back to the concept. Use when the user wants to truly understand, teach, or explain something and would benefit from a story that sticks and spreads, rather than a flat explanation. Especially good for abstract, counterintuitive, or "hard to feel" concepts. Not for exact syntax or step-by-step procedures where precision matters.

Fable　寓言

A fable is not a cute analogy. It is the oldest, most transmissible teaching form humans ever invented — and it has a structure. The job of this skill: take an abstract concept and cast it as a concrete allegory whose moral maps faithfully back to the concept.

When to use

• The user asks to understand / explain / teach a concept, and a story would help it stick.
• The concept is abstract, counterintuitive, or hard to build intuition for (e.g., eventual consistency, gradient descent, compound interest, entropy).
• The user wants something they can retell to others.

When NOT to use

• The user needs exact syntax, a precise spec, or a step-by-step procedure — give that directly. A fable that distorts precision is worse than no fable.
• The concept is too thin to carry narrative stakes (a single config flag, a trivial fact). Say so honestly instead of forcing one.
• The user is debugging or needs a factual fix — be direct, not literary.

How it gets invoked

By default reactive: the user asks to understand/explain a concept, or runs /fable <concept>. Proactively offer (one line, then wait — never dump a long fable unsolicited) when you detect an abstract/counterintuitive concept or repeated confusion（"还是没懂 / 为什么"）. Full protocol + output options (genre / length / audience / language): references/invocation.md.

Two modes — match the form to what you're teaching

• 寓意式 (moral fable) — for an abstract principle (复利, 熵, 局部最优): situation → conflict → resolution → one moral. The 7-step craft below produces this.
• 模型式 (structural allegory) — for a domain or mechanism (filesystem, TCP handshake, garbage collection): a complete, faithful, navigable model where every part maps to a real component, and the learner reasons about the model to derive behavior. Full craft in references/fable-craft.md; worked example: the Great Archive (filesystem) in references/examples.md.

Rule of thumb: one idea to feel → 寓意式; a system to understand and predict → 模型式.

The craft (core recipe)

1. Distill the principle. What is the one core idea the reader must walk away with? One moral per fable — never two.
2. Find the allegory. A concrete situation whose internal logic mirrors the concept's logic. The mapping must be structural, not decorative.
3. Cast characters. Concrete, vivid, ideally archetypal (the fox, the apprentice, the two kingdoms). Anthropomorphism is allowed only if it sharpens the idea — never if it misleads.
4. Build the conflict. The tension in the story must be the concept's tension, dramatized — not a conflict pasted on top.
5. Resolve. The ending must force the principle to surface naturally, without lecturing.
6. State the moral, then map it back. End with an explicit 「寓意 ↔ 概念」mapping so the reader can verify it term by term.
7. Fidelity test (mandatory, do not skip). Could this exact fable plausibly serve a different concept? If yes → it is too generic → redo. The allegory must be specific to THIS concept.

Language-quality loop (mandatory — this is the core)

A correct draft is not enough; the prose must be alive. Never ship a first draft. Full method in references/language-quality.md; in short:

1. Calibrate — re-read one master in the target genre (Aesop / 庄子 / La Fontaine). Feel the temperature gap.
2. Critique the draft against the quality checklist（terseness · concrete-not-abstract · no preaching · real stakes · one image at 120% · anti-slop）.
3. Revise — cut 20%, replace every abstract label with a concrete image, kill every sentence that preaches.
4. Re-run the fidelity test — revision must not break the 寓意↔概念 mapping.

Genre palette

Pick the tradition that fits the concept's texture:

• 伊索式 (Aesopic animal fable) — short, punchy, single sharp moral. Best for clean cause-and-effect principles.
• 庄子 / 韩非式 (Chinese 寓言) — philosophical, often paradoxical, sometimes unsettling. Best for counterintuitive or systems-level ideas.
• Parable — human-scale, ethical stakes. Best for ideas about behavior, incentives, or trade-offs.

Anti-slop (quality bar — non-negotiable)

• Restrained, vivid prose. No purple-gradient language, no emoji-as-icons, no forced cuteness, no SVG-drawn characters.
• One detail at 120%, everything else at 80%. A single image carries the weight; the rest stays quiet.
• If the concept resists a clean fable, say so — never distort the concept to make the story neat. Honesty over charm.
• The moral must be unambiguous. (Current AI struggles to extract morals from fables — so make ours extractable on purpose.)

Output shape (suggested)

【寓言】 <title>
<the story — concrete, short, with real stakes>

【寓意】 <one-line moral>

【寓意 ↔ 概念 映射】
- <story element>  ↔  <concept element>
- ...

References

• references/pedagogy.md — why fables teach (Egan, Bruner, empirical memory studies, Aesop as natural experiment).
• references/fable-craft.md — how to craft them: full manual, genre templates, fidelity test, anti-slop checklist, concept→genre routing.
• references/language-quality.md — the core: how to make prose actually good (8 principles, master study, contrastive calibration, draft→critique→revise loop, quality checklist).
• references/examples.md — 7 moral fables across three genres + 1 模型式 structural allegory (文件系统/大档案馆) + 1 honest-refusal case (幂等性), each with its fidelity check. The quality bar.
• references/invocation.md — when/how to fire: reactive default, proactive offer (never unsolicited dump), output options, /fable command.

Status: v0.2. Craft, language quality, invocation, and the distributable plugin layout are all in place. Next: end-to-end test in a live Claude Code session + README visual polish (see README roadmap).