prompy

Prompy — Deep-Dive Workflow

This is the manual deep-dive flow. Activated only by the user explicitly typing /prompy:prompy [optional prompt] or asking for "the full report card" or "deep dive on this prompt".

This skill is separate from the inline co-pilot/auto-pilot behavior injected by the SessionStart hook. The hook gives terse, one-line traces on every prompt. This skill gives the verbose, fenced, edit-iteration deep dive on explicit request only.

---

Phase 0 — Intake

Read $ARGUMENTS:

• If an argument is present: use it as the target prompt
• If no argument: ask once — "What prompt would you like me to deep-dive on?" — then proceed with the user's next message

---

Phase 1 — Use-case Detection

Classify the target prompt into one of five use-cases by scanning for keyword signals: coding, writing, creative, strategy, or other.

Load references/mode-matrix.md for the keyword table and per-use-case strategy.

Announce the detection:

"Treating this as a [use-case] prompt."

If the user supplied an override flag (--coding, --writing, --creative, --strategy), use it and announce "Using [use-case] as specified."

---

Phase 2 — Score and Explain

Score on 5 dimensions (1-5 each) using references/scoring-rubric.md:

• Clarity, Specificity, Context, Actionability, Mode-fit

Present the Analysis Block from references/output-templates.md:

✦ Prompy [deep-dive] — analysis

Original: "[first 80 chars]…"
Use-case: [detected]

SCORE BREAKDOWN:
  Clarity       [x/5] — [one-sentence rationale]
  Specificity   [x/5] — [one-sentence rationale]
  Context       [x/5] — [one-sentence rationale]
  Actionability [x/5] — [one-sentence rationale]
  Mode-fit      [x/5] — [one-sentence rationale]

Overall: [Grade] ([score]/100)

What's weakest:
  • [Dimension]: [one-line reason]
  • [Dimension]: [one-line reason]

Want me to explore context, or will you supply what's missing?
Type "explore" or reply with the missing info directly.

A-grade short-circuit: If overall grade is A (90+), declare strong and stop. Use the "Already Strong" template. No further enrichment.

---

Phase 3 — Context Gathering

Path A — User supplies context

Incorporate the reply into Phase 4 without further questions, unless something critical is missing.

Path B — Prompy explores

Strategy depends on detected use-case (references/mode-matrix.md):

Coding:

1. Run git rev-parse --git-dir 2>/dev/null and test -f CLAUDE.md to check for codebase
2. If codebase exists → spawn Explore subagent with the coding mandate (200-word digest max)
3. If no codebase → ask the inline coding questions in one block

Writing / Creative / Strategy / Other:

• If the project has CLAUDE.md / README / docs/ that informs the prompt → spawn a brief read-only subagent to extract style/context (200-word digest max)
• Otherwise → ask the use-case's inline questions in one block

Subagent prompt template (use this verbatim for any use-case that warrants a subagent):

You are a read-only context gatherer. Your only job is to return a structured digest, max 200 words total.

Target prompt: "[the user's original prompt]"
Use-case: [coding|writing|creative|strategy|other]

Tasks:
1. Read CLAUDE.md if it exists
2. For coding: Glob/Grep relevant files in src/, app/, lib/, components/
   For writing/creative/strategy: Read README, docs/, and any style guides

Return this structure:

Relevant files found:
  - [path]: [one-line description]

Existing patterns / style signals:
  - [brief description]

Tech / domain signals:
  - [detected]

Missing context the prompt assumes:
  - [what the user didn't mention]

Do NOT dump file contents. Return the digest only.

---

Phase 4 — Enrichment

Generate the improved prompt using the original prompt plus the gathered context.

Load references/claude-prompting-principles.md for the enrichment decision guide. Load references/prompt-patterns.md for use-case-specific examples.

Enrichment rules (non-negotiable):

1. Preserve intent. Never change what the user wants. Only add specificity, context, and structure.
2. Trace every addition. Every enrichment decision must map to a principle in claude-prompting-principles.md. No guesswork.
3. Quality over length. A shorter, tighter rewrite is better than padding.
4. No fiction. Do not invent file paths, function names, constraints, or context. If a path is unknown, ask one short question.
5. Re-score. After enrichment, re-score the prompt to populate the report card.

Use-case-specific priorities:

• Coding: Specificity + Actionability
• Writing: Context + Clarity
• Creative: Mode-fit + Context
• Strategy: Actionability + Context
• Other: Even weight

---

Phase 5 — Show & Approve

Present using the Improved Prompt Block template from references/output-templates.md:

✦ Prompy [deep-dive] — improved prompt ready.

---[ PROMPY: IMPROVED PROMPT ]---
[Improved prompt text — verbatim, copy-pasteable]
---[ END PROMPY PROMPT ]---

---[ PROMPY: REPORT CARD ]---
                  BEFORE    AFTER
  Clarity         [x/5]  →  [x/5]
  Specificity     [x/5]  →  [x/5]
  Context         [x/5]  →  [x/5]
  Actionability   [x/5]  →  [x/5]
  Mode-fit        [x/5]  →  [x/5]

  Overall:  [Grade] ([score]/100)  →  [Grade] ([score]/100)

What changed:
  1. [Specific change] — [why per principles]
  2. [Specific change] — [why per principles]
  3. [Specific change] — [why per principles]

What this teaches you:
  "[One transferable principle the user can apply to future prompts.]"
---[ END REPORT CARD ]---

Approve (enter / "yes") / Edit (type "edit [your changes]") / Use original (type "original")

Wait for the user's response:

• Approve → Phase 6 with improved prompt
• Edit → apply changes, re-display block, ask "Updated. Approve (enter) or edit again?"
• Original → Phase 6 with original prompt

---

Phase 6 — Execute

Run the approved prompt as if the user submitted it directly. Do not prepend Prompy framing, headers, or score recaps to the response — Prompy's job is finished at the end of Phase 5.

---

When to use this skill vs the inline behavior

Scenario	Use
User types a vague prompt without invoking anything	Inline (hook) co-pilot or auto-pilot trace
User types /prompy:prompy [prompt] or /prompy [prompt]	This deep-dive skill
User asks "give me the full report card" or "deep dive on this"	This deep-dive skill
User is already in the middle of an inline co-pilot exchange	Continue the inline flow, do not switch to deep-dive

---

Common Rationalizations — Reject These

Thought	Reject because
"The original prompt was fine"	Score it. If it's A, declare strong and stop. If not, the score shows why.
"This is just a simple request"	Simple requests benefit most from specificity.
"I'll add a little context"	Every addition must trace to a principle. No guesswork.
"The user probably means X"	Ask or derive from context. Never invent intent.
"I'll skip the report card to save time"	The report card is mandatory in deep-dive — it's how the user learns.

---

Verification Checklist

• Use-case detected and announced
• Scoring used the 1-5 scale and weights from references/scoring-rubric.md
• A-grade short-circuit honored if original scored 90+
• Context gathering used the right path (subagent for coding+codebase or writing/creative/strategy with project docs, inline questions otherwise)
• Subagent digest, if used, was ≤ 200 words
• Every enrichment addition traced to a principle in claude-prompting-principles.md
• No fictional file paths, constraints, or context invented
• Improved Prompt Block appears in correct fenced format
• Report card shows before/after scores per dimension
• "What this teaches you" line is concrete and transferable (not generic)
• User confirmed execution (approve / edit / original)
• Execution happened with the correct prompt, without Prompy framing in the response