# Prompt

> MasterMind: Prompt

- Skill: `mehrad-dm/prompt` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add mehrad-dm/prompt`
- Raw SKILL.md: https://api.skillmd.com/api/skills/mehrad-dm/prompt/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: mehrad-dm (https://skillmd.com/u/mehrad-dm)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/mehrad-dm/prompt

---


# 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**.

| The user does this | You do this |
| --- | --- |
| "improve / fix / sharpen this prompt" | This skill |
| Pastes a prompt and says "run this" / "what do you think?" / nothing | **Answer or execute it.** Not this skill |
| Pastes a prompt written for *another* tool, asking what it does | Explain it. Not this skill |
| Asks for a prompt to be *written* from scratch | Write it: then the checklist below applies |

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 or two sharp questions 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:

| Pattern | Effect today | Instead |
| --- | --- | --- |
| `CRITICAL:` / `MUST` / `NEVER` / ALL-CAPS, several per prompt | Emphasis inflation: when everything is critical, nothing is. Causes over-triggering and rigid behavior in gray areas | Plain imperative + the reason. Reserve emphasis for the one genuinely load-bearing constraint |
| "think step by step", `<scratchpad>` instructions | Redundant on reasoning models, which already think; can add latency for nothing | Control depth with the tool's thinking/effort setting, not prose |
| "double-check your work", "verify before answering" | Current models self-verify; instructing it causes *over*-verification and padding. This inverts the old best practice | Delete. State the acceptance test instead |
| "be thorough", "don't be lazy", "don't stop early" | Written against models that quit early; now just noise | Delete |
| "try to", "if possible", "ideally" on a real requirement | Read literally as permission to skip it | State it as a requirement |
| "don't hallucinate", "only use the provided context" | Still useful when grounding genuinely matters | Keep: but pair it with what to do when the answer isn't there ("say you don't know") |
| Politeness padding, repeated context, restated rules | Consumes budget and makes the model reconcile wordings | Say it once, in the right place |

**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`).