MasterMind: Prompt

The single biggest lever on AI output quality is the prompt. Most weak results aren't a model failure, they're an under-specified request. This skill rewrites a rough ask into a prompt an AI executes well: clear intent, only the context that matters, structured, token-efficient.

The user's own words are not yours to rewrite. Fire only on an explicit ask, propose rather than apply, and name every requirement you added or cut, ~/.mastermind/engineering/core/rigor.md § Stay in scope.

Do not fire unless asked

Auto-invocation is the danger here: rewriting a prompt the user meant you to answer replaces their work with your paraphrase and loses whatever they actually wanted. The bar is an explicit request to improve the prompt.

If it's genuinely ambiguous, ask one question before rewriting. Guessing wrong wastes a turn; rewriting unasked destroys their text.

The prompt stays theirs

The output is a proposal, never an action:

1. Never execute the rewritten prompt: not in the same turn, not "to show it works". Hand it back.
2. Never drop a requirement. Every constraint in the original survives, or you say out loud that you cut it and why. Silent removal is the failure mode that makes this skill dangerous.
3. Never add a requirement they didn't imply. Additions get named in "what changed": a specific the user never chose (a framework, a length, a tone) is a guess wearing their voice.
4. Never rewrite a prompt containing credentials, private data, or client names into a form that moves them somewhere new. Flag them and quarantine instead (quarantine).

First: get the real intent

If the goal is ambiguous, ask one sharp question before rewriting: the rewrite carries only requirements the user actually implied. You sharpen their intent; it stays theirs.

The rewrite checklist (apply what fits: keep it lean)

1. Lead with the task. State the goal in the first line, plainly. Treat the AI like a sharp new hire: say exactly what "done" looks like.
2. Give load-bearing context only: the why, the audience, the stack/constraints, what already exists. Cut backstory that doesn't change the output. Context is never the cruft; padding is.
3. Be explicit and concrete. Replace vague adjectives ("nice", "modern", "clean") with specifics (what, for whom, which constraints, which examples to match).
4. Structure it. Separate the parts, context / task / requirements / output format, with headings or XML-ish tags (<context>…</context>) so the model can parse roles of text.
5. Show an example, not just a description: but show two or three varied ones, labeled illustrative. A single gold example gets copied: the model matches its length, tone and structure.
6. Set the role when it sharpens tone/expertise ("You are a senior accessibility engineer…"). One line. A role statement is not a substitute for saying what the output must contain.
7. Pin the output contract: format, length, what to include/exclude, and any must-nots.
8. Say what to do, not what to avoid. "Answer in three sentences" beats "don't be verbose"; a list of prohibitions can anchor the model toward the very failure it names.

Keyword effects: what words actually do to a modern model

Prompts written for 2023-era models are now actively harmful, because current models follow instructions far more literally. What to strip, and what to reach for instead:

Placement matters as much as wording. Long documents go first, the question last: a model attends best to the start and end, and a question buried above 50k tokens of context gets lost. If the same preamble is reused across calls, keeping it stable and at the front is also what makes prompt caching hit (core/agent-loop.md).

Token efficiency (efficient ≠ lossy)

Cut politeness padding, redundancy, and repeated context; compress prose to bullets; keep every detail that changes the output and no more. Fewer tokens and a sharper signal, never a shorter prompt that drops requirements. Length is not the metric: a too-short prompt produces generic output because the model fills the gaps with safe defaults.

Output

Return, in this order:

1. The optimized prompt: ready to paste, in a copyable block. Nothing else in that block.
2. What changed & why: 2–4 bullets, and every one of them names an addition or a removal (e.g. "added output format; cut 3 lines of backstory; made 'fast' concrete = <2.5s LCP").
3. Open questions: anything still genuinely ambiguous the user should decide.

Flag any change of scope out loud. If the request implies a product/business decision, surface it rather than guessing (product-sense.md).