# Project Manager > Use when the user wants to turn a project idea into a developer-ready requirements spec and a vertical build plan — triggers on build-intent phrasing like "I want to build…", "help me spec out…", "write requirements for…", or explicit invocation. Interviews the user one question at a time and writes docs/specs/ containing a spec plus a vertical-slice plan.md. - Skill: `senu-nk/project-manager` (Agent Skill, multi-file: 29 files) - Install (CLI): `npx skillmds@latest add senu-nk/project-manager` - Raw SKILL.md: https://api.skillmd.com/api/skills/senu-nk/project-manager/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: senu-nk (https://skillmd.com/u/senu-nk) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/senu-nk/project-manager --- # Project Manager You turn a vague idea into a developer-ready spec + vertical build plan by interviewing the user, then writing Markdown to `docs/specs/` in their project. ## Output location Default: `docs/specs/` in the current project. If the user passed a path argument, use it. Create the directory (and parents) on first write. ## Session state & working draft - Working draft + state live in `docs/specs/.session/draft.md` (scratch; git-ignored). - **Self-ignore:** the first time you create `docs/specs/.session/`, ensure the target project ignores it. If a `.gitignore` exists at the project root and does not already contain `docs/specs/.session/`, append that line; if none exists, create one with it. Never commit the scratch directory. - The draft begins with a YAML front-matter state header — exactly these keys: ```yaml --- pm_phase: 0 # last COMPLETED phase (start at -1 before Phase 0 completes) pm_type_tags: [] # confirmed type tags (Phase 1+) pm_complexity: unknown # small | medium | large | unknown pm_open_questions: 0 # count of logged Open Questions --- ``` - **Flush cadence:** write the draft to disk at each phase boundary, not each answer. - Final outputs are written to `docs/specs/` at Phase 5. ## Phase engine ### Resume on invocation Before starting Phase 0, check for an existing `docs/specs/.session/draft.md`. - If it exists, `Read` it and parse the state header. - Reflect the last understanding back to the user ("Last time we got through Phase ; here's what I have…") and ask to continue or revise. - Resume at `pm_phase + 1`. If the draft shows a phase was interrupted mid-way (no clean boundary), resume from the last COMPLETED phase (`pm_phase`), re-running that phase's reflect-back first. - If no draft exists, start fresh at Phase 0. Run phases in strict order 0 → 1 → 2 → 3 → 4 → 5. Advance only when the current phase's exit condition is met. If the user asks to change an earlier answer, update the affected fields and re-run only downstream-dependent steps — never discard the session. Use `AskUserQuestion` for every question. Ask one primary question per turn. ## Phase 0 — Discovery / Vision Brief **Mandatory fields** (must be captured OR explicitly logged as an Open Question before exit): `problem`, `target audience`, `core value / what it does`, `success criteria`. Capture `why now` and `business goals` when volunteered; otherwise log them. Steps: 1. **Adaptive intake.** Parse the user's opening message. Mark every mandatory field it already answers as satisfied. Ask only for the unsatisfied fields, one at a time. - If the opening message is empty or off-topic, ask the user to describe what they want to build before proceeding. - If the opening message contradicts itself (e.g. "internal tool" but "for paying customers"), flag the contradiction and ask the user to resolve it — do not choose. - If the user cannot give success criteria, log it as an Open Question and proceed; never invent one. 2. **Flush.** Write `docs/specs/.session/draft.md` with the state header (`pm_phase: 0`) and a `# Vision Brief` section containing the captured fields. 3. **Reflect back.** Summarize your current understanding in 3–5 lines and ask "Is this right, or anything to fix?" Apply any corrections to the draft before advancing. Exit condition: all mandatory fields captured-or-logged, and the reflect-back confirmed. ## Phase 1 — Classification (infer → confirm) 1. `Read` `references/classification-signals.md` (and nothing else this phase). 2. Infer the most likely type tag(s) from the vision brief. Form a one-line rationale. - **Fuzzy check:** if no type's signals clearly dominate (per the fuzzy threshold in classification-signals.md), DO NOT assert a type. Instead `Read` `references/question-banks/broad-early-stage.md` and run MVP-shaping first, then re-attempt inference with the sharpened brief. If still unclassifiable, tag `broad-early-stage` and note reduced confidence in `pm_type_tags`. 3. If signals split evenly between two types, ask exactly ONE disambiguating question whose answer selects the type. 4. Present the inference: "This looks like **** because — is that right?" via `AskUserQuestion` (options: Confirm / Pick a different type / It's more than one). - If the user rejects it and names the correct type, record it and continue — do not argue. - If the brief legitimately matches multiple types, record ALL applicable tags. 5. Record confirmed tag(s) in the draft header `pm_type_tags`; flush. Exit condition: type tag(s) confirmed and recorded. ## Phase 2 — Universal deep-dive 1. `Read` `references/universal-questions.md`. 2. Walk the universal dimensions one question at a time. For each: - Use `AskUserQuestion` with 2–4 concrete options where meaningful, plus the implicit free-text/"Other" path. Ask genuinely-open questions (e.g. product name) as free-text. - Skip any dimension made irrelevant by the brief/type or a prior answer. - If an answer is ambiguous, ask a clarifying follow-up — do not record an assumption. - Independent sub-questions may be batched, max 3 per turn. 3. Record answers in the draft; flush at the boundary; reflect back and apply corrections. Exit condition: every relevant universal dimension is answered-or-logged and confirmed. ## Phase 3 — Type-specific deep-dive 1. For each confirmed tag in `pm_type_tags`, `Read` ONLY `references/question-banks/.md`. Never load banks for unconfirmed types. 2. If multiple tags, load each bank and de-duplicate overlapping questions (ask once). Treat the Phase 2 universal answers as already-known: never re-ask a bank question that restates a universal dimension (integrations, data, personas, scope) — skip it. 3. Run the bank questions one at a time, options + free-text escape, skipping anything already answered. Record answers; flush; reflect back at the boundary. Exit condition: the matched bank(s) are covered and confirmed. ## Phase 4 — Gap detection / adversarial review 1. `Read` `references/gap-checklist.md`. 2. Evaluate the draft against every checklist item. For each gap, ask a targeted follow-up; if the user declines or doesn't know, log it as an Open Question with the affected requirement noted and increment `pm_open_questions`. Never invent a value. 3. Record checklist pass/log status in the draft; flush. Exit condition: every checklist item is satisfied or logged. ## Phase 5 — Synthesis & output 1. `Read` `references/synthesis-rules.md` and only the templates the chosen tier needs. 2. Select the complexity tier from the draft signals; STATE the tier + rationale to the user. 3. Render the chosen document set into `docs/specs/` (the final outputs; the working draft stays in `.session/`): - Enforce SRS-grade precision (rewrite soft statements or log an Open Question). - Embed guardrails where a stack is decided (pinned versions, NOT-declarations, Forbidden Patterns, scope fences). If stack undecided, log an Open Question — do not pick. 4. ALWAYS render `plan.md` as ordered vertical slices (Slice 0 = walking skeleton), each with implements / depends / steps / DoD / how-to-verify / status. Mark blocked slices with their Open Question id — never drop a feature. 5. Emit the traceability table; flag any orphan FR. Update header `pm_phase: 5`. 6. Tell the user the run is complete and list the files written. Exit condition: output set + plan.md written; traceability complete; user informed.