Guide

An interactive tour through the shipped skills. Each module teaches one skill by running it against sample data in samples/. Designed for PMs, designers, analysts, or engineers - the skill adapts framing to the role set in CLAUDE.md.

Pre-emit checklist (run BEFORE every chat message in this skill)

Before you send any message while /guide is active, audit your draft against these rules. If any fails, fix it before sending.

1. Vault paths are backticked. Any token that looks like a file path (contains / or ends in .md) must be wrapped in backticks so Claude Code renders it as a clickable reference. A path without backticks is a bug - it renders as plain text and the user can't click it.
2. File-argument commands use `@`. When you tell the user how to run a skill with a file input, the path must be @-prefixed so Claude Code's file autocomplete activates: ` /meeting @samples/sample-meeting-transcript.md , not /meeting samples/sample-meeting-transcript.md `.
3. Module intros below are printed verbatim. Each module has a literal intro block in this file. Print that block exactly as written - do not rephrase, do not add extra paragraphs, do not strip backticks. The blocks are short on purpose.
4. Gate order. If the current turn is a first-run orientation, a resume, or a numeric jump, the message ends with Ready to start Module N? (y/n/skip) and nothing else - no module intro on the same turn. If the user just typed next, there is NO gate - go straight to the next module's verbatim intro.

Progress tracking

Progress is stored in .claude/memory/guide-progress.md. The .claude/memory/ directory ships with the template (see its README.md), so do NOT run mkdir or ls to check - use the Read tool directly, and if Read returns "file does not exist", treat it as a first run and create the file with Write.

When you create the progress file for the first time, use this content (substitute today's date for YYYY-MM-DD):

---
tags: GuideProgress
started: YYYY-MM-DD
---

# /guide progress

- [ ] Module 1: /meeting
- [ ] Module 2: /today morning
- [ ] Module 3: /decision
- [ ] Module 4: /communicate
- [ ] Module 5: /create-epic
- [ ] Module 6: /competitive-research
- [ ] Module 7: Capstone
- [ ] Module 8: Extend your workspace

Mark a module complete ([x]) only once the user finishes it (see "End-of-module recap" for the specific moment).

Mode selection

Keep tool calls minimal and silent - no Bash ls, no mkdir, no "let me check..." narration. The user wants a coach, not a script.

Check $ARGUMENTS:

• Empty (/guide with no args):
• Read .claude/memory/guide-progress.md.
• If Read returns "file does not exist", it's a first run: show the First-run orientation block (verbatim), create the progress file with Write, then stop. The orientation block ends with the "Ready to start Module 1? (y/n/skip)" prompt. On the user's next turn with y, print the Module 1 verbatim intro and stop.
• If progress exists, show the Resume line (one line: ` You're on Module N of 8 - [Module title]. /guide <n> to jump, /guide reset to start over. ), then ask Ready to start Module N? (y/n/skip), then stop. On y`, print the Module N verbatim intro.

• `next`:
• Read .claude/memory/guide-progress.md.
• If missing, treat exactly like empty (first-run flow).
• If progress exists, find the first uncompleted module and print its verbatim intro directly - NO "Ready?" gate. The user already said next; asking again is friction.

• A number 1-8 (e.g. /guide 3):
• Read (or create) progress file.
• Print one line: Jumping to Module N - [title].
• Ask Ready to start Module N? (y/n/skip) and stop.
• On y, print the Module N verbatim intro.

• `reset`:
• Overwrite guide-progress.md with a fresh copy (all modules unchecked, started: = today).
• Print one line: Progress reset.
• Then show the First-run orientation block.

The "Ready?" prompt at a gate is the ONLY prompt for that turn. Do not preview the intro on the same turn as a gate - that buries the gate.

Answers at a "Ready?" gate:

• y - print the module's verbatim intro on the next turn
• n - stop (one-line acknowledgement)
• skip - mark the current module [x], move to the next gate

First-run orientation block (print verbatim)

Welcome to **/guide** - an interactive tour of the shipped skills.

**What this is**: 8 short modules (~5-10 min each), one per shipped skill, run against sample data in `samples/`. Do 1-2 per session over days, not all at once. Progress is saved in `.claude/memory/guide-progress.md`, so you can stop and resume. The framing adapts to the role set in `CLAUDE.md`.

**The 8 modules**:
1. `/meeting` - raw meeting notes to structured note + tasks
2. `/today morning` - daily planning (mood, energy, focus items)
3. `/decision` - document a product decision with options + trade-offs
4. `/communicate` - draft a Slack / email / async update
5. `/create-epic` - raw idea to structured epic draft
6. `/competitive-research` - build a sourced competitive matrix
7. Capstone - chain `/meeting` then `/decision` then `/communicate`
8. Extend your workspace - run `/opportunity-solution-tree`, add or write more skills

**Commands**:
- `/guide` - continue / resume (or start at Module 1 the first time)
- `/guide next` - go to the next uncompleted module (no confirmation)
- `/guide <n>` - jump to a specific module (e.g. `/guide 3`)
- `/guide reset` - wipe progress and start over

**At a "Ready?" gate**: `y` start, `n` stop, `skip` mark done and move on.

Ready to start Module 1? (y/n/skip)

Print this block and STOP on the same turn. Do not append the Module 1 intro here - it's for the next turn, after y.

Module verbatim intros

Each intro below is printed verbatim when the user is ready to start that module (after y to a gate, or directly after next). Do not rephrase, do not strip backticks, do not add extra paragraphs.

Module 1 intro

**Module 1 of 8 - Your first meeting note** (~5 min)

`/meeting` turns raw meeting notes into a structured note with decisions, action items, and follow-up tasks in `Dashboard/tasks.md`. Sample input: `samples/sample-meeting-transcript.md` (open if you want to see what it handles).

**To run now**: type `/meeting @samples/sample-meeting-transcript.md` yourself, or just say `run it` and I'll invoke it for you.

Module 2 intro

**Module 2 of 8 - Morning planning** (~5 min)

`/today morning` picks up to 3 focus items for today, drawn from `Dashboard/tasks.md` and your weekly P-Tasks. Ritual skill - no sample file, you run it against yourself.

**To run now**: type `/today morning` yourself, or say `run it`. The skill will ask about mood, energy, self-care, and your calendar.

Module 3 intro

**Module 3 of 8 - Logging a decision** (~5 min)

`/decision` gathers context, drafts 2-3 options with trade-offs, creates a decision note in `Loose Notes/Work/`, and proposes follow-up tasks. Sample context: `samples/sample-decision-context.md`.

**To run now**: type `/decision should we ship the auth rewrite before or after the onboarding redesign` yourself, or say `run it`. When the skill asks for additional context, paste the sample file's content.

Module 4 intro

**Module 4 of 8 - Draft a crisp async update** (~5 min)

`/communicate` drafts Slack / email / async messages matched to the audience, pulling context from your recent decisions and meetings. Sample context: `samples/sample-update-context.md`.

**To run now**: type `/communicate update engineering leadership on the auth-first decision - Slack` yourself, or say `run it`. The draft comes back already formatted for the channel you picked.

Module 5 intro

**Module 5 of 8 - Creating your first epic** (~5 min)

`/create-epic` turns a raw idea into a structured epic draft at `epics/YYYY-MM-DD - Title.md` with stage `Explore`. Sample input: `samples/sample-epic-idea.md`.

**To run now**: type `/create-epic @samples/sample-epic-idea.md` yourself, or say `run it`. The skill will ask 3-5 clarifying questions (target persona, metric, risks) - answer honestly, and unknowns get marked TBD.

Module 6 intro

**Module 6 of 8 - Competitive research** (~5 min)

`/competitive-research` builds a sourced competitive matrix where every observation links to a source. Sample prompt: `samples/sample-competitor-prompt.md`.

**To run now**: type `/competitive-research @samples/sample-competitor-prompt.md` yourself, or say `run it`. The skill will confirm the competitor set, then gather observations from public sources.

Module 7 intro

**Module 7 of 8 - Capstone: chain three skills** (~10 min)

The payoff module. You run three skills in sequence and each one reads the artifacts of the previous one - nothing gets re-explained. Sample input: `samples/sample-capstone-meeting.md`.

**The chain** (3 steps):
1. `/meeting @samples/sample-capstone-meeting.md`
2. `/decision invoice portal scope for billing UI revamp`
3. `/communicate update cross-functional stakeholders on the invoice portal scope decision - Slack`

**To run now**: say `run it` and I'll walk you through all three steps in order. You can also run each step yourself - tell me which you prefer.

Module 8 intro

**Module 8 of 8 - Extend your workspace** (~10 min)

Three things: (1) run the bundled external skill `/opportunity-solution-tree`, (2) how to add a skill from the internet, (3) how to write your own.

**To run now** (the Torres tree on a real outcome): type `/opportunity-solution-tree reduce new-user activation drop-off from 40% to 25%` yourself, or say `run it`. After the tree runs, I'll cover parts 2 and 3.

Role adaptation

Read CLAUDE.md for the user's role. Adapt framing lightly - do NOT rewrite the verbatim intros. Add at most one sentence of role-framing AFTER the verbatim intro (on the same turn, before stopping) when the role is clearly non-default:

• Designer: "For your role, think of Module 5 as 'draft a design brief' and Module 6 as 'design-pattern research'."
• Analyst / Researcher: "Modules 5 and 6 map most directly to your work - plan to spend extra time there."
• Engineer: "Modules 5 and 6 work for technical investigations too - frame them as RFCs and tech-stack comparisons."
• PM / Senior PM / Head of Product (default): no extra sentence needed.

Keep it to one sentence. The intros do the heavy lifting.

Running a module (after the intro prints)

After the verbatim intro, stop and wait. The user drives from here:

• "run it" (or similar): you invoke the skill on their behalf. Narrate one short line first ("Running /meeting on the sample - it'll ask you to confirm any tasks before writing."). Let the other skill do its thing. When it's done, jump straight to the end-of-module recap.
• User runs the command themselves: step back, let the other skill run. When they return to the guide thread, print the end-of-module recap.
• "skip": mark the module done and go to the next module's verbatim intro directly (no gate - same as next).
• "stop" / "later" / "n": acknowledge in one line and exit. Do not mark the module done.

Never create files, tasks, or notes without the per-skill confirmation the other skill already bakes in. The guide itself never writes vault content - it only invokes skills and updates .claude/memory/guide-progress.md.

Module 7 (Capstone) runtime rule

Module 7 has three sub-steps (/meeting then /decision then /communicate). After step 1 finishes, say one line: ` Step 1 of 3 done. Ready for step 2 (/decision)? Say run it or run it yourself. ` Same pattern after step 2. After step 3, go to the end-of-module recap.

If the user says next before all three steps are done: ask one question. You've done N of 3 capstone steps. Finish the capstone (say "run it" to continue), or mark it done and move to Module 8? Respect their choice.

End-of-module recap

When a module finishes, print a short conversational recap - not a code-fenced card. Include:

1. One line marking completion: Module N of 8 done (N/8 complete).
2. One or two lines on what was just created, with real filenames in backticks.
3. One short line on when to reach for this skill in real work (the takeaway).
4. One line pointing to the next module: ` Next: Module N+1 - [title]. [One-line hook]. Say next to start. `

Then update .claude/memory/guide-progress.md - mark this module [x].

For Module 8, use the end-of-guide block below instead.

Example tone for Module 1 recap (write fresh each time, don't copy verbatim):

Module 1 of 8 done (1/8 complete). You now have a structured meeting note at Meetings/2026-04-15 - Quarterly planning sync - Mobile team.md and one action item in Dashboard/tasks.md under "This week". When raw notes land in your inbox, reach for /meeting instead of copy-pasting into a doc - it extracts commitments you'd otherwise forget. Next: Module 2 - Morning planning. Pick 3 focus items, not 10. Say next to start.

End-of-guide block (use for Module 8 recap)

After Module 8's /opportunity-solution-tree run and the parts 2-3 narration, mark Module 8 complete and print:

**You've completed /guide.** All 8 modules done.

You now have the full toolkit:
- Daily rituals (`/today morning/evening`) for focus and close-out
- Meeting + decision + communication infrastructure (`/meeting`, `/decision`, `/communicate`)
- Epic / research / discovery (`/create-epic`, `/competitive-research`, `/opportunity-solution-tree`)

**What to do next**:
1. Tomorrow morning, kick off your day with `/today morning`.
2. Run `/personalize deep` to add MCP detection, initiatives, and people profiles (takes ~10 min).
3. When you catch yourself doing the same thing three times, write a skill for it - copy an existing skill folder in `.claude/skills/` as a starter.

Go ship something.

Do NOT skip the prominent completion message. This is the moment the user has been working toward - they deserve a clear "done" signal.

Module reference material

The blocks below are reference material - what each skill does and what artifacts to expect - NOT scripts to paste into chat. Use them to inform your recaps and any mid-module Q&A. The verbatim intros above are what the user sees; these notes are your own context.

Module 1 reference: /meeting

• What it does: turns raw meeting notes into a structured note with decisions, action items, and a list of follow-up tasks for you.
• Why: raw meeting notes rot; a structured note is searchable and surfaces the tasks you committed to without relying on memory.
• Artifacts: Meetings/YYYY-MM-DD - Title.md + task in Dashboard/tasks.md + link in today's journal.
• In-real-work note for the recap: mention the three input modes - pass a saved file path, run /meeting with no args to browse unprocessed files, or run /meeting and paste the transcript directly.

Module 2 reference: /today morning

• What it does: opens today's journal, asks mood / energy / self-care / yesterday's evening, takes your calendar, suggests up to 3 focus items.
• Why: 3 focus items beats 10. Capacity-aware (low-energy days = fewer items).
• Artifacts: journals/YYYY/MM-Month/DD-MM-YYYY.md filled in + focus marker on picked tasks in Dashboard/tasks.md.

Module 3 reference: /decision

• What it does: gathers vault context (+ GitHub if configured), drafts 2-3 options with pros/cons, creates a decision note, proposes follow-up tasks.
• Why: decisions made in Slack / meetings get forgotten, relearned painfully, sometimes silently reversed.
• Artifacts: Loose Notes/Work/YYYY-MM-DD - Decision - Topic.md + link in today's journal + tasks in Dashboard/tasks.md.

Module 4 reference: /communicate

• What it does: drafts a message for Slack, email, or async doc - tone matched to the audience; pulls context from recent decisions and meetings.
• Why: PMs re-explain the same context over and over; the vault is memory, the skill translates.
• Artifacts: a ready-to-paste draft in chat, formatted for the chosen channel (single-asterisk bold for Slack, proper markdown for email).

Module 5 reference: /create-epic

• What it does: raw idea to structured epic draft using templates/epic-template.md, stage Explore, unknowns marked TBD.
• Why: most ideas die between "we should think about that" and a reviewable document; this closes the gap in 5 minutes.
• Artifacts: epics/YYYY-MM-DD - Title.md + follow-up tasks in Dashboard/tasks.md + link in today's journal.
• Designer-role note: the same skill serves drafting a design brief - use sections 1 (Value Prop), 2 (User Problem), 7 (Design Planning).

Module 6 reference: /competitive-research

• What it does: produces a sourced competitive matrix; every observation has a source link, marked observed: or inferred:.
• Why: "what competitors do" answered by opinion breaks in leadership reviews; evidence-driven research survives.
• Artifacts: research/YYYY-MM-DD - Competitive - Topic.md with matrix, synthesis, gaps, confidence levels.

Module 7 reference: Capstone (/meeting then /decision then /communicate)

• What it teaches: real PM work chains skills; the vault becomes memory so each skill builds on the previous one's artifacts.
• The chain: see the verbatim intro above for the three commands.
• Artifacts across the three skills: meeting note in Meetings/, decision note in Loose Notes/Work/, Slack draft in chat, follow-up tasks in Dashboard/tasks.md.
• Observation to surface in the recap: notice that step 2 and step 3 never re-asked for background - they read the vault files step 1 created.

Module 8 reference: Extend your workspace

• Part 1: /opportunity-solution-tree (MIT-ported from phuryn/pm-skills; see .claude/skills/opportunity-solution-tree/ATTRIBUTION.md). Walks a Teresa Torres tree: outcome to opportunities to solutions to experiments.
• Part 2 (narrate after the tree runs): how to add an external skill - check license (MIT / Apache OK), copy the skill folder into .claude/skills/, keep attribution, restart Claude Code, test it, add to CLAUDE.md. Browse phuryn/pm-skills for starters.
• Part 3 (narrate after part 2): how to write your own - one skill per repeated workflow (>3 times), folder at .claude/skills/[name]/SKILL.md with frontmatter (name, description, argument-hint) and a workflow body. Copy an existing skill as a starter. Name by the action (/meeting), not the object (/process-meeting-notes).
• Recap: use the End-of-guide block above. Mark Module 8 done.

Notes

• Modules are designed to be done over days, not in one sitting. 1-2 per session is sustainable.
• The guide never writes to the vault (meetings, decisions, tasks) - only skills do, and only after their own confirmation. The guide writes only to .claude/memory/guide-progress.md.
• If a module's sample file is missing, tell the user and stop - do not invent sample content on the fly.
• reset starts over cleanly; skip moves on without completing.