Prompt Generator

The capstone skill that orchestrates the full prompt generation pipeline: discovery → classification → routing → generation. Produces ready-to-use Claude Code session prompts with glossary, verification checklist, and optional plan scaffolding.

Phase 1 — Discover

Check if the skills registry is current:

REGISTRY="D:/ailocal/acm-ai/skills-registry.json"

# Check existence and age (regenerate if missing or >1 hour old)
if [ ! -f "$REGISTRY" ]; then
  echo "Registry missing — running skill-discovery"
  RUN_DISCOVERY=true
else
  # Check modification time (cross-platform: stat -c on Linux, stat -f on macOS)
  MTIME=$(stat -c "%Y" "$REGISTRY" 2>/dev/null || stat -f "%m" "$REGISTRY" 2>/dev/null)
  NOW=$(date +%s)
  AGE=$((NOW - MTIME))
  if [ $AGE -gt 3600 ]; then
    echo "Registry stale ($((AGE / 60)) min old) — running skill-discovery"
    RUN_DISCOVERY=true
  fi
fi

If RUN_DISCOVERY=true, invoke /skill-discovery to refresh the registry before proceeding.

Read D:/ailocal/acm-ai/skills-registry.json after confirming it is current.

Phase 2 — Classify

Apply /request-classifier to the user's request. Produce a RequestClassification JSON.

If the classification is ambiguous (two types score within 1 point of each other, or the request contains mixed signals), present the candidate classifications to the user and ask for confirmation before proceeding:

I see two plausible classifications for your request:
  A) pipeline / complexity 6 / plan ON
  B) improvement / complexity 5 / plan ON

The strategies diverge here — A routes to a tmux team, B routes to a solo agent with subagent gates.
Which fits better, or shall I go with A (pipeline) since there are LangGraph signals?

Phase 3 — Route

Apply /prompt-router with the confirmed classification + skills registry.

Produce a PromptPlan JSON. If the plan is complex (agent_strategy=tmux-team OR plan_mode=true with 5+ skills), present it for user confirmation before generating:

Routing plan:
  Type: pipeline / complexity 7 / plan mode ON
  Skills: /planning-with-files, /langgraph-fundamentals, /acm-observability, /pydantic-models-py
  Strategy: tmux-team (3 panes: orchestrator, backend-dev, verifier)
  Context7: LangGraph docs + LangChain docs
  Output: prompt-pack → docs/sprint-artifacts/prompt-packs/

Proceed? [Y/n]

Phase 4 — Generate

4a — Load Template

Read the master template from:

D:/ailocal/acm-ai/.claude/skills/prompt-generator/references/prompt-template.md

4b — Build Glossary

Read the glossary builder:

D:/ailocal/acm-ai/.claude/skills/prompt-generator/references/glossary-builder.md

Select the domain(s) based on domain_signals from the classification:

• extraction, pipeline, graph, node, langgraph → Pipeline domain
• component, page, UI, React, css, frontend → Frontend domain
• Always include → General domain

Cap at 15 entries. Prioritize terms that appear in the user's original request text.

4c — Populate Template

Fill in all {{ variable }} placeholders:

4d — Plan Mode Scaffolding

If plan_mode=true, also create these files in docs/sprint-artifacts/:

task_plan.md skeleton:

# Task Plan: {session_title}
Date: {YYYY-MM-DD}
Status: IN PROGRESS

## Goal
{one-sentence goal}

## Steps
- [ ] Step 1
- [ ] Step 2
...

## Risks
- (none identified yet)

findings.md skeleton:

# Findings: {session_title}
Date: {YYYY-MM-DD}

## What Was Discovered
(populate during session)

## Decisions Made
(populate during session)

progress.md skeleton:

# Progress: {session_title}
Date: {YYYY-MM-DD}

## Completed
(none yet)

## In Progress
(none yet)

## Blocked
(none yet)

Phase 5 — Output

Select output format from PromptPlan.output_format:

terminal (default)

Print directly with clear markers:

══════════════════════════════════════════
  GENERATED PROMPT — {session_title}
══════════════════════════════════════════
{populated template content}
══════════════════════════════════════════

copy-paste

Print in a fenced code block so the user can copy it cleanly:

```prompt
{populated template content}
```

prompt-pack

Save to docs/sprint-artifacts/prompt-packs/{YYYY-MM-DD}-{slug}.md where {slug} is the session title kebab-cased.

Print a confirmation:

Prompt pack saved to:
  docs/sprint-artifacts/prompt-packs/2026-03-13-fix-extraction-timeout.md

--save flag override

If the user passed --save, always save to the prompt-pack path regardless of output_format, AND print to terminal.

Quick Start

Three example invocations:

1. Simple fix (terminal output, no plan):

/generate-prompt "Fix the building sidebar not loading when source has 0 buildings"

→ Classifies as bug-fix/simple, routes to solo+systematic-debugging, outputs inline.

2. Complex feature (saved prompt-pack + plan scaffolding):

/generate-prompt "Add MinerU as a new extraction provider with fallback chain" --save --tmux

→ Classifies as pipeline/complex, routes to tmux-team+langgraph-fundamentals, saves to prompt-packs/, creates task_plan.md.

3. Refactor with explicit format:

/generate-prompt "Refactor pre-extraction stages to reduce LLM calls" --format prompt-pack

→ Classifies as improvement/medium, routes to solo+verification-before-completion, saves as prompt-pack.

Flags Reference

Notes

• If skills-registry.json is missing, Phase 1 runs /skill-discovery automatically — this adds ~5 seconds but ensures accurate skill selection
• Plan scaffolding files are created relative to the repo root; the session prompt references them with absolute paths
• Context7 directives in the generated prompt are ready-to-execute — copy them verbatim at session start
• The generated prompt is designed to be pasted as the first message of a new Claude Code session, not run in the current conversation