Prompt Architect Fable

Prompt Architect — Fable 5 Edition

CHANGELOG

v1.0-fable — Jul 2026. Standalone fork of prompt-architect v2.0 (calibrated Opus 4.7), recalibrated for Claude Fable 5. Produced through an internal maintenance-review process (staged review against one empirical exhibit); ruling standards: the official Anthropic Prompting Claude Fable 5 guide and the Jul 2026 effort documentation. The Opus sibling remains in use, unchanged.

Lockstep contract (governance). The architecture decision module — seven signals, verdict logic, guards — plus its threshold constants is bound in lockstep with prompt-optimizer-fable and is inherited from it verbatim in this fork: any change there propagates to both Fable skills. The capability layers of the two Fable skills are explicitly free to differ. The Opus originals deliberately retain the prior-generation threshold constants — same module, different constants, by design; a future review must not "fix" this asymmetry as drift.

Changes vs. v2.0:

• Technique library re-derived and extended: #5 redefined as scoped reasoning within the prompt (extended-thinking budgets no longer exist as a control surface); #16 flagged surface-gated and unverified on Fable 5; #19 intent-context and #20 brevity/selectivity added; the agentic four-pack enters as the overlay's composite technique block.
• Execution-mode overlay added: a binary axis orthogonal to the 10 buckets — interactive (default) / agentic — that injects the Fable 5 agentic pattern set into any bucket's stack.
• Architecture module recalibrated (LOCKSTEP, inherited): fidelity test primary; provisional numeric backstop, VALIDATE-marked; prior-generation bands retired.
• Surface parameter added (chat / code / cowork / harness) gating run settings, #16, and overlay detection.
• Run-settings element added to both output formats (Fable effort ladder, high default, bidirectional; never inside the prompt).
• New frontmatter description: explicit-invocation-only triggering in the four-skill routing space; a stale private routing reference dropped; version string moved out of the description.
• Claude-specific notes → Fable 5 notes, per-claim re-derivation with evidence markers; prior-generation ceiling claim deleted; reasoning-echo guard added.
• Worked examples rebuilt: lithium and SWF examples recalibrated in place; third example swapped for an agentic-mode exemplar teaching the overlay.
• Conditional chain delivery: full one-turn delivery when the vehicle heuristic is unambiguous; confirmation pause only when marginal.
• Prose-economy pass with the discrimination rule: behavioral micro-instruction stated once; content specification (buckets, techniques, examples) preserved at density.

Provisional items carried with VALIDATE markers: the numeric feasibility backstop; the #7 famous-register amendment (n=1). Tighten or relax only with evidence.

---

Purpose

Convert a described task into a technique-grounded v1 draft prompt for Claude Fable 5 — or, when the task warrants it, into a technique-grounded chain of stage prompts plus a Project orchestrator. The skill does this by:

1. Classifying the task against the 10-bucket taxonomy, with the execution-mode overlay
2. Deciding the output architecture (single-turn vs. chain)
3. Applying the right technique stack from the Top-Tier Prompting for Professionals v2 framework, Fable-calibrated
4. Recommending surface-aware run settings for the draft

This skill is the generative counterpart to prompt-optimizer-fable (which is evaluative). Use the architect when you don't yet have a draft; use the optimizer when you do.

Core philosophy

Choose the architecture before choosing the structure. Single-turn is the default delivery vehicle, but not the only one. When the work is genuinely complex — multi-deliverable, sequentially dependent, checkpoint-bearing, or compression-costly — chain architecture produces materially better output than any single-turn prompt could. The architect makes that call explicitly, names the signals, and produces a chain deliverable when chain is the right answer. Drafting a beautifully technique-grounded single-turn prompt for a task that deserved a chain is an alignment failure between the skill's mission (state-of-the-art output) and its mechanics (single-turn polish).

On Fable 5, restraint is activation. Fable 5's instruction-following is strong enough that one brief, clear instruction steers behavior that previously required enumeration — and instruction density inherited from prior-model habits can degrade its output. Every technique, rule, and scaffold in a v1 draft must clear a higher bar than on any prior model. The 5-technique cap is not a limitation on Fable 5; it is the point.

When to run the architect vs. other skills

• Architect first, then optimizer (full rigor path): reserved for high-stakes prompts you will reuse or that anchor a critical decision. Architect produces v1; prompt-optimizer-fable audits and produces v2.
• Architect alone: most non-trivial tasks. The v1 draft is usually good enough to run directly.
• Optimizer alone: when a draft prompt already exists and needs auditing.
• Dedicated skill instead of architect: if the task maps to an existing dedicated domain skill, route to it — a dedicated skill already encodes the right technique stack for its domain. The architect is for tasks that don't fit a dedicated skill.

Intake — surface declaration

SURFACE ∈ {chat (default) | code | cowork | harness} — where the drafted prompt will run.

Read only from an explicit user declaration ("this is for Claude Code", "Cowork task", "harness prompt"); never infer from topic. If absent, default to chat and state the assumption in the run-settings element. SURFACE gates the run-settings content, technique #16, and contributes to execution-mode detection below. It does not affect classification.

---

The 10-bucket taxonomy

Every task is classified against these ten buckets. A task usually fits 1–3 buckets; multi-bucket tasks union their technique stacks (see Step 3).

Bucket 1 — Fact-grounded document analysis

Source material exists and is pasted by the user. The task is to extract, summarize, cross-reference, or analyze the pasted content.

• Default stack: #15 (context loading + delimitation) + #17 (CoVe for fact-dense) + #8 (uncertainty calibration)
• Situational adds: #3 (output shaping), #18 (framework invocation)
• Example tasks: loan agreement review, 10-K extraction, prospectus summarization, contract diligence

Bucket 2 — Research and investigation

Source material does NOT yet exist. The model must retrieve it (web search, tools) or generate it from trained knowledge. The task is both information-gathering AND synthesis.

• Default stack: #4 (Socratic — MANDATORY scoping gate) + #8 (uncertainty calibration) + #15 (delimitation for retrieved sources) + #17 (CoVe for fact-dense parts) + #3 (output shaping) + #1 (success criteria)
• Situational adds: #10 (contrast pairing when researching one thing vs another), #13 (devil's advocate for contested topics)
• Example tasks: aluminium market analysis, cosmetics market sizing, economic relationship investigation, country/sector deep-dives
• CRITICAL: The Socratic gate is non-negotiable. Research tasks are dangerously underspecified by default. Skipping #4 produces generic wikipedia-grade output.

Bucket 3 — Knowledge document / teaching artifact creation

The output serves a FUTURE reader — often the author themselves, later — who doesn't have the context of the current conversation. The task is to build a durable reference, class, or note.

• Default stack: #1 (success criteria — future-reader variant) + #10 (contrast pairing) + #3 (pedagogical output shaping) + #7 (worked-example anchoring for recurring series) + #18 (framework invocation if teaching a named framework) + #8 (uncertainty calibration)
• Situational adds: #15 (if building from pasted source material), #17 (if fact-dense)
• Example tasks: course or lecture notes, a Black-Litterman lesson, a named-framework reference document
• Future-reader success criteria variant: "A top-tier answer will let a reader who has never seen this topic understand the load-bearing intuition in under 10 minutes and retain enough precision to apply it to a new case."

Bucket 4 — High-stakes decision with ambiguity

Low reversibility, framing may be wrong, real consequences. The task is to decide (or to avoid deciding badly).

• Default stack: #4 (Socratic) + #11 (pre-mortem) + #6 (anti-sycophancy licensing), then #9 (adversarial review) on the output
• Situational adds: #13 (devil's advocate), #8 (uncertainty calibration)
• Example tasks: position sizing on a new thesis, job application decisions, structural portfolio changes, tactical allocation shifts

Bucket 5 — Framework application to a specific case

A named framework exists (user's or external) and the task is to apply it to a specific input.

• Default stack: #18 (reference-anchored reasoning) + #15 (if source material is pasted) + #3 (structured output matching framework shape)
• Situational adds: #8 (uncertainty calibration), #14 (iterative refinement)
• Example tasks: applying a named performance-evaluation framework to a specific fund, a manager-assessment rubric to a specific manager, a structured scoring framework to a specific case

Bucket 6 — Analytical synthesis / thesis work

Inputs already exist (in the user's own knowledge or in the conversation), need to be synthesized into a position, argument, or recommendation.

• Default stack: #1 (success criteria) + #5 (scoped reasoning) + #3 (output shaping)
• Situational adds: #6 (anti-sycophancy) + #9 (adversarial review) for defense-ready theses, #11 (pre-mortem), #13 (devil's advocate)
• Example tasks: "is sector X still attractive given Y", thesis defense memos, position reviews, cross-asset synthesis

Bucket 7 — Recurring deliverable with house style

A format the user produces repeatedly with known conventions — memos, briefings, template fills.

• Default stack: #7 (worked-example anchoring) + #3 (output shaping) + #2 (contextual priming)
• Situational adds: #1 (success criteria), #14 (iterative refinement)
• Example tasks: briefing in a new domain replicating prior structure, a recurring course note in the established format

Bucket 8 — Default well-scoped analytical work

Clear input, clear question, standard output. No special structural requirements.

• Default stack: #1 (success criteria) + #2 (contextual priming) + #3 (output shaping)
• Situational adds: whatever the specifics suggest
• Example tasks: "explain X", "compare A vs B", standard analytical questions

Bucket 9 — Design / architecture work

Build a system, framework, workflow, or analytical infrastructure. Output is a structural solution to a multi-constraint problem.

• Default stack: #4 (Socratic — MANDATORY for constraint elicitation) + #11 (pre-mortem on the design) + #13 (devil's advocate between design choices) + #3 (structured output for the architecture) + #1 (success criteria)
• Situational adds: #18 (if building on an existing framework)
• Example tasks: a strategic-asset-allocation engine, new framework design, skill design, workflow infrastructure
• Architecture note: Bucket 9 tasks typically fire signals 2 (sequential dependency) and 3 (checkpoint value) and often warrant CHAIN. Run Step 2 normally; if CHAIN fires, deliver the chain.

Bucket 10 — Persuasive writing / external communication

The output must move a specific reader toward a specific action or belief. Success is reader-centric, not analytical.

• Default stack: #2 (contextual priming — about the READER, not the author) + #7 (worked-example anchoring, per its Fable amendment) + #3 (output shaping to persuasive conventions) + #1 (success criteria — "what would make the reader say yes") + #14 (iterative refinement)
• Situational adds: #9 (adversarial review — "read this as the skeptical recipient")
• Example tasks: cover letters, client pitches, external memos, LinkedIn posts, investor communications
• Reader-centric success criteria variant: "A top-tier answer will make [specific reader] [specific action] within [timeframe]."
• NOTE: If a dedicated skill covers a specific external-communication type, route to it instead.

---

The execution-mode overlay (new in v1.0-fable)

A binary axis orthogonal to the buckets — the bucket is the cognitive nature of the work; the mode is how the run executes:

• Interactive (default) — the user is present; the prompt initiates a normal conversational turn or short exchange.
• Agentic — the prompt initiates autonomous or semi-autonomous multi-step work: tool use, long runs, work continuing without the user watching.

Detection rule: explicit user statement beats surface lean. "Run it end to end", "I'll be away", "unattended", "overnight", "pipeline" → agentic. Surface lean: harness and Cowork lean agentic; chat leans interactive; Claude Code is genuinely both — a quick interactive fix or a multi-hour autonomous run. If the mode is unstated and the choice is consequential, ask (one line) rather than assume.

Effect: when agentic mode is active, the Agentic execution block (a composite technique — see the library, block AX) is injected into the unioned stack of whatever bucket(s) apply, at mandatory-for-the-task priority. It occupies one slot in the 5-cap; the union-and-cap discipline is unchanged. Agentic research is still Bucket 2; agentic framework application is still Bucket 5 — the overlay changes the technique stack, never the classification.

Never inject agentic machinery into interactive-mode drafts, regardless of surface.

---

Workflow

Step 1 — Classify (10-bucket + mode)

Identify which buckets apply. Most non-trivial tasks fit 1–3 buckets; do not force one bucket if multiple apply. Detect the execution mode per the overlay's detection rule. If classification is genuinely ambiguous between buckets whose stacks differ materially, run clarification mode (below) before Step 2.

State the bucket(s), the mode, and the considered-and-rejected alternatives explicitly. This is the anti-sycophancy guard — it forces the skill to defend its classification.

Step 2 — Architecture decision (LOCKSTEP module — identical to prompt-optimizer-fable)

This step decides the output architecture for the v1 draft: single-turn, single-turn (ceiling) (strained but fits), or chain (sequential stage prompts with handoffs and optional human-in-loop checkpoints). The decision drives downstream branching of Steps 3–4.

Default: single-turn. Chain has to earn it through named signals; ambiguity resolves toward single-turn. On Fable 5 the bar for chain is higher than on prior models — longer default turns mean genuinely large work fits in one turn.

The seven signals are evaluated from the user's task description (no prompt exists yet — that's the architect's whole point).

Trigger signals

Primary signals:

1. Multi-deliverable — the task requires two or more distinct artifacts with materially different shapes (e.g., data sheet + analytical memo + scenario matrix). Multiple sections of one memo do not count; the deliverables must be genuinely different in form.
2. Sequential dependency — Phase B's quality materially depends on Phase A's substantive output, and Phase A is non-trivial (research, gathering, calculation). Pure structural sequencing ("intro then body then conclusion") does not count.
3. Checkpoint value — there exists at least one point between phases where human judgment materially improves the final output (methodology selection, scope decisions, data validation, comparable selection). A ceremonia

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: viktor-milev
• Source: viktor-milev/claude-skills
• License: MIT

Install and usage instructions live in the source repository linked above.