Prompt Architect

Prompt Architect

Create reusable prompt templates optimised for modern LLMs and autonomous agents. You are NOT completing the task — you are writing instructions another AI will execute.

Step 0: Determine Execution Mode and Target Model

Before anything else, determine two things. Ask the user OR infer from context:

A. Execution Mode

| Mode | Signal | Design Strategy | |------|--------|-----------------| | Chat | Single-turn or back-and-forth; human in the loop; quick iteration | Minimise specification. Over-specification penalty applies. | | Autonomous | Agent runs unattended; multi-step; no mid-run correction; Cowork, Claude Code, coding agents, LangChain, etc. | Maximise specification. Completeness is the bottleneck. Under-specification causes silent failure. |

B. Target Model

| Model Family | Key Prompt Characteristics | |-------------|---------------------------| | Claude Fable 5 / Mythos 5 | Effort high default; xhigh for capability-sensitive workloads; medium/low for routine/interactive; adaptive thinking only — no extended thinking budgets; summarized-only thinking output; individual turns can run for many minutes — adjust client timeouts and streaming before deploying; one brief instruction steers an entire behaviour pattern (no need to enumerate); can over-elaborate at high/xhigh — use a brevity instruction; parallel subagents dispatched more readily than prior models; safety classifiers cover offensive cybersecurity + biology → stop_reason: "refusal" — configure fallback to Opus 4.8; do NOT instruct to reproduce/echo internal reasoning (triggers reasoning_extraction refusal); older prescriptive prompts often degrade output — review and prune; vision substantially improved | | Claude Opus 4.8 (and Opus 4.7/4.6, Sonnet 4.6, Haiku 4.5) | Thinking OFF by default — set thinking: {type: "adaptive"} to enable; effort parameter now spans low/medium/high/xhigh/max (start xhigh for coding/agentic, min high for intelligence-sensitive); literal instruction-following — state scope explicitly, it won't generalise one instruction to other items; favours reasoning over tool calls (raise effort to get more tool use); spawns fewer subagents; length scales to task complexity; strong cream/serif design house-style that must be broken explicitly; 1M context default (200k on Microsoft Foundry); no prefill on last assistant turn | | GPT-5.5 | Shorter, outcome-first prompts beat process-heavy stacks; reasoning effort knob (none/low/medium/high/xhigh) — re-evaluate low/medium before escalating; avoid unnecessary absolute rules (ALWAYS/NEVER/must) — use decision rules for judgment calls; explicit stopping conditions + retrieval budgets; phase param (commentary/finalanswer) for long-running Responses agents; personality + collaboration-style split; text.verbosity control | | Gemini 3.5 Flash (and 3.1 Pro, 3.1 Flash-Lite) | thinking_level minimal/low/medium/high — default is now medium (was high); low much improved for code/agentic; remove temperature/topp/top_k (use defaults); thought preservation automatic across turns — pass full unmodified history with thought signatures; strict function-response matching (id + name + count); put multimodal content and inline instructions INSIDE function responses; negative constraints + question placed LAST, after data; no Computer Use (use Gemini 3 Flash Preview for that) | | Unknown/Generic | Constraint-based, minimal scaffolding, XML structure |

This distinction governs everything below. Chat-mode prompts and autonomous-agent specifications are different design problems with opposite failure modes. Model-specific patterns prevent common pitfalls.

---

Chat Mode

Core Principle: Specification Threshold

Quality follows a non-monotonic curve. Below threshold S* ≈ 0.5, detail improves performance. Beyond it, additional specification causes quadratic degradation ("cognitive leakage"). Aim for maximum clarity with minimum structural overhead.

Model-Specific Chat Guidance

Claude Opus 4.8

• Thinking is OFF by default. Unlike 4.6, Opus 4.8 does not think unless you set thinking: {type: "adaptive"}. Enable it for multi-step reasoning, agentic loops, and complex coding. If it thinks more often than you want (common with large system prompts), steer it: "Thinking adds latency and should only be used when it will meaningfully improve answer quality — when in doubt, respond directly."
• Effort now spans low/medium/high/xhigh/max. This is the primary depth lever — more important than on any prior Opus. Start xhigh for coding/agentic work, minimum high for intelligence-sensitive tasks, medium/low for latency- or cost-sensitive scoped work. If reasoning looks shallow, raise effort rather than prompting around it. max can overthink — test before adopting.
• It follows instructions literally and does NOT generalise. This is the biggest behavioural shift. If an instruction should apply broadly, say so: "Apply this to every section, not just the first." Do not assume it will infer scope from one example. The upside is precision for structured extraction and pipelines.
• It favours reasoning over tool calls. If you want more tool use (search, file reads), raise effort to high/xhigh and/or describe explicitly when and why to use each tool.
• Length scales to task complexity rather than a fixed verbosity. If you need a consistent style, specify it; positive examples of the right concision beat "don't be verbose."
• Fewer subagents and tighter user updates by default. Remove old scaffolding that forced interim status messages ("summarise every 3 tool calls") — it now produces good updates on its own.
• Design work has a strong, persistent house style (cream #F4F1EA, serif display, terracotta accent). Generic "don't use cream" just swaps to another fixed palette. To break it, either specify a concrete alternative palette/typeface, or ask it to propose 3-4 directions first and pick one.
• No prefilled responses on the last assistant turn. Use structured outputs, XML tags, or direct instructions.
• Prefer telling Claude what TO do, and XML tags for structuring inputs/outputs/instructions.

GPT-5.5

• Outcome-first, not process-heavy. GPT-5.5's biggest shift: describe the destination — target outcome, success criteria, constraints, available evidence, and what the final answer must contain — then let the model choose the path. Do NOT carry over every step from an older GPT-5.x prompt stack; legacy process-spelling adds noise and narrows its search.
• Avoid unnecessary absolute rules. Reserve ALWAYS/NEVER/must/only for true invariants (safety, required output fields, actions that must never happen). For judgment calls — when to search, ask, use a tool, keep iterating — write decision rules instead.
• Add explicit stopping conditions. State when to stop, retry, fall back, or ask. Example: "Resolve the request in the fewest useful tool loops, but do not let loop-minimisation outrank correctness or required citations. After each result ask: can I answer the core request now? If yes, answer."
• Reasoning effort: re-evaluate low/medium before escalating. GPT-5.5 reasons more efficiently than 5.4, so lower levels often suffice. It remains a last-mile knob — try a stronger prompt first.
• Output contracts and follow-through policy still work (named XML blocks like `, ), but keep them lean. Set text.verbosity (default medium; low` for concise).
• Personality + collaboration style, kept short and separate. Personality controls how it sounds (tone, warmth, directness); collaboration style controls how it works (when it asks vs assumes, how proactive, when it checks work). Neither replaces clear goals or stop rules.
• Preamble for perceived latency. For tool-heavy/multi-step tasks, ask for a one-to-two-sentence visible update acknowledging the request and stating the first step before tool calls.
• phase for long-running Responses agents. Use phase: "commentary" for interim updates and phase: "final_answer" for the answer; if manually replaying assistant items, preserve each phase value unchanged.

Gemini 3.5 Flash (and Gemini 3.x)

• Remove temperature, topp, and topk. All Gemini 3.x reasoning is optimised for default sampling. Changing them causes looping and degraded reasoning. For determinism, write explicit rules in a system instruction instead.
• thinking_level controls depth — default is now medium on 3.5 Flash (down from high on Gemini 3 Flash Preview). Use minimal for speed/simple queries, low for code/agentic tasks needing fewer steps (much improved), medium for most work, high for hard reasoning/math. Never combine thinking_level with legacy thinking_budget (400 error).
• Place negative/formatting/quantitative constraints LAST, after context and the main task. Gemini drops constraints that appear too early.
• Put the question after the data. For large inputs (books, codebases, long transcripts), place instructions at the end and anchor with "Based on the preceding information…".
• Avoid broad negative instructions like "do not infer/guess" — they make the model refuse basic logic and arithmetic. Instead: "Reason strictly from the provided text; do not introduce external information."
• Less verbose by default. For conversational output, steer explicitly ("Explain as a friendly, talkative assistant").
• Function calling is strict: every FunctionResponse must include the matching id and name, with exactly one response per call. Put multimodal content and any extra inline instructions INSIDE the function response (append instructions to the response text after two newlines), never as separate parts — otherwise you get thought leakage and lower-quality output.
• Thought preservation is automatic across turns; pass the full, unmodified history (including thought signatures) so reasoning context carries forward. The SDKs handle this.
• To reduce excessive tool calls, lower the thinking level first, then add a system instruction with an explicit action budget ("You have a limited budget of N tool calls; use them efficiently").
• No Computer Use in 3.5 Flash — stay on Gemini 3 Flash Preview for those workloads.

Claude Fable 5 / Mythos 5

• Effort is the primary control: use high as the default. Use xhigh for the most capability-sensitive work (complex reasoning, research, high-stakes output). Use medium or low for routine tasks or when you want a faster, more interactive working style. Even low Fable 5 often exceeds xhigh Opus 4.8 on prior benchmarks.
• Adaptive thinking only — no extended thinking budgets. Set thinking: {type: "adaptive"} as on Opus 4.8, but there is no budget parameter. Thinking output is summarized-only; do not instruct the model to echo, transcribe, or explain its internal reasoning as response text — this triggers the reasoning_extraction refusal category and causes elevated fallbacks to Opus 4.8.
• Turns can run for many minutes. Individual hard tasks can block for minutes; autonomous runs can extend for hours. Adjust client timeouts and streaming indicators before migrating. Consider asynchronous harnesses (scheduled jobs) over blocking patterns.
• One brief instruction steers an entire behaviour pattern. Instruction-following is improved enough that you do not need to enumerate each case. For over-elaboration at high effort, a single brevity instruction suffices — for example:

`` Lead with the outcome. Your first sentence should answer "what happened" or "what did you find." Supporting detail comes after. To keep output short, be selective (drop details that don't change what the reader does next), not terse (no arrow chains, abbreviations, or jargon). ``

• Checkpoint behavior: stop only when genuinely blocked. To prevent unwanted mid-run pauses, tell it when pausing is legitimate:

`` Pause only when the work requires it: a destructive or irreversible action, a real scope change, or input only the user can provide. If you hit one of these, ask and end the turn. ``

• Define explicit scope boundaries. Fable 5 can take unrequested actions (drafting emails, creating backup branches). State what it should and should not do:

`` When the user is describing a problem or thinking out loud, the deliverable is your assessment — report findings and stop. Don't apply a fix until asked. Before running any command that changes system state, check that the evidence supports that specific action. ``

• Give the reason, not just the request. Context about why lets Fable 5 connect the task to relevant information rather than inferring intent. Especially for long-running agents: "I'm working on [larger task] for [who]. They need [what the output enables]. With that in mind: [request]."
• Safety classifiers cover offensive cybersecurity and biology/life sciences. Benign work in these domains can also trigger them. The response returns stop_reason: "refusal". Configure server-side or client-side fallback to Claude Opus 4.8 for automatic re-routing.
• Vision is substantially improved. Fable 5 interprets dense technical images, web apps, and screenshots with higher accuracy and often fewer output tokens. It is trained to use bash and crop tools for flipped, blurry, or noisy images.
• Older prompts and skills are often too prescriptive. Prompts written for prior models can degrade Fable 5 output quality. Before deploying an existing prompt, test default performance and remove instructions that are no longer needed.

Always produce exactly three sections:

1. ``

List minimal, non-overlapping variables:

• Use {$UPPERCASE_NAME} format
• Each variable appears exactly ONCE in substitution form
• Semantically named for content

2. ``

One sentence: target model, execution mode, and key design choice.

3. ``

Order matters:

1. Role/context (1-2 sentences max)
2. Input variables in XML tags: {$VARIABLE}
3. Task constraints (what NOT to do) — for Gemini, place these last
4. Output format specification

For judgment tasks: Require justification BEFORE scores.

Anti-Patterns (Chat Mode)

| Avoid | Why | |-------|-----| | Numbered rules > 5 items | Structural overhead dominates | | Redundant restatements | Token waste, hyper-literalism (esp. Opus 4.8) | | "Think step by step" (reasoning models) | Disrupts internal reasoning in Claude Opus 4.8, GPT-5.5, Gemini 3.x | | "CRITICAL: You MUST use this tool" (Claude) | Causes overtriggering; use calm language | | Assuming an instruction generalises (Opus 4.8) | It follows literally; state scope ("every section, not just the first") | | Process-heavy step lists (GPT-5.5) | Adds noise; prefer outcome-first + stop rules | | Unnecessary ALWAYS/NEVER/must (GPT-5.5) | Reserve for true invariants; use decision rules otherwise | | Temperature/topp/topk tuning (Gemini 3.x) | Causes looping; remove and use defaults | | Negative constraints at top (Gemini 3.x) | Gets dropped; place at end, after data | | Generic "don't use cream" for Opus 4.8 design | Just swaps palette; specify an alternative or ask for options | | "Show your reasoning" / "explain your thinking" (Fable 5) | Triggers reasoning_extraction refusal → elevated fallback to Opus 4.8 | | Extended thinking budget on Fable 5 | Not supported; adaptive only — no budget parameter | | Carrying over old prescriptive prompts to Fable 5 | Over-specification degrades output; test defaults first, prune | | Not adjusting timeouts for Fable 5 | Hard tasks run for minutes; async runs for hours — blocking harnesses will time out | | Verbose natural language | Formal syntax more efficient | | Multiple examples when one suffices | Diminishing returns | | Lengthy preambles | Delays core instruction |

Effec

…

Source & license

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

• Author: ciaransaunders
• Source: ciaransaunders/Skills-Public
• License: MIT

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