Step 1: Setup

Get your toolkit configured and ready to use.

Prerequisites

Before starting, make sure you have:

• Claude Code or Cursor installed
• GitHub CLI (gh) — Install guide
• Python 3.9+ — usually pre-installed on macOS

1. Clone and Open

git clone https://github.com/davethegut/core-ai-pm-workflow.git
cd core-ai-pm-workflow

Open in your tool of choice:

# Claude Code
claude

# Cursor
cursor .

2. Authenticate GitHub CLI

gh auth login
gh auth status  # Verify it worked

This enables the deep-dive, my-initiatives, and doc-writer (GitHub issue creation) skills.

3. Set Up Google OAuth (Optional)

If you want to use the calendar and gdocs-share skills, you'll need Google OAuth. This requires a Google Cloud project with the Calendar API and Google Docs API enabled.

Create a Google Cloud project

1. Go to Google Cloud Console
2. Create a new project (or use an existing one)
3. Enable the Google Calendar API and Google Docs API
4. Create OAuth 2.0 credentials (Desktop application type)
5. Download the credentials JSON file

Configure credentials

Store your OAuth client credentials in a central location:

mkdir -p ~/.ai-pm-workflow
# Copy your OAuth client JSON to ~/.ai-pm-workflow/client_secret.json

The first time you use either skill, a browser window will open for you to authorize access. After that, tokens are stored locally at ~/.ai-pm-workflow/ and auto-refresh.

See skills/calendar/SKILL.md and skills/gdocs-share/SKILL.md for detailed setup instructions.

4. Configure Your AI Tool

Claude Code

Skills are automatically picked up from the skills/ directory via CLAUDE.md. No additional configuration needed.

Cursor

Create symlinks so Cursor finds the skills:

mkdir -p .cursor/skills
ln -s ../../skills/* .cursor/skills/

5. Create Your Output Directories

mkdir -p output/{html,presentations,docs,competitor-research}
mkdir -p tasks
mkdir -p data/competitors/profiles

6. Verify It Works

Try these commands with your AI assistant:

"What skills do I have available?"
"Write a concept one-pager for a new feature idea"

If both work, you're ready. Head to Step 2: Read.

Troubleshooting

Step 2: Read — Pull in Your Context

Before you write anything, you need context. This step teaches you to pull information from your existing tools into your AI workspace.

Skills Used

• Calendar — See what's on your plate today
• Google Docs — Import existing documents for analysis

Exercise 1: Check Your Calendar

Say:

"What meetings do I have today?"

The AI will fetch your Google Calendar and present a summary — grouped by time, with meeting links and conflict warnings.

Try this next:

"What's on my calendar this week?"
"Do I have any conflicts tomorrow?"

What you learned: You can pull real-time context from Google Calendar without switching apps.

Exercise 2: Import a Google Doc

Find a Google Doc you've been working on — a draft, notes from a meeting, or a spec. Share the link:

"Read this Google Doc: [paste your URL]"

The AI converts it to markdown and can now:

• Summarize it
• Analyze it
• Use it as context for other skills

Try this next:

"Summarize the key decisions in this doc"
"What questions does this doc leave unanswered?"

What you learned: You can bring external documents into your AI workspace and work with them immediately.

Exercise 3: Combine Calendar + Docs

This is where it gets powerful. Try:

"What meetings do I have today? For any doc links in the calendar events, pull them in and give me a prep summary for each meeting."

What you learned: Skills compose. The calendar skill feeds context into the docs skill, and you get meeting prep without any manual work.

What's Next

Now that you can pull in context, let's use it to research something. Head to Step 3: Research.

Step 3: Research — Understand Before You Build

Two skills that turn hours of research into minutes.

Skills Used

• Deep Dive — Research any GitHub repo and produce an HTML reference doc
• Competitor Research — Structured competitive analysis

Exercise 1: Deep Dive a Repository

Pick a GitHub repo you work with (or any public repo you're curious about). Say:

"Deep dive into the authentication system in [org/repo]"

The AI will:

1. Ask you to confirm the topic, repo, and output directory
2. Search the codebase for relevant files, types, and architecture
3. Pull recent issues and PRs for context
4. Generate a polished HTML reference document

Open the HTML file in your browser — it's a self-contained, shareable reference page.

Try these:

"Deep dive into the plugin system in grafana/grafana"
"Teach me about the router in remix-run/remix"
"Onboard me to the CLI framework in oclif/oclif"

What you learned: You can onboard to any codebase in minutes instead of hours. The HTML output is shareable with your team.

Exercise 2: Research a Competitor

Pick a competitor in your space. Say:

"Research [competitor name]'s approach to [feature area]"

The AI will:

1. Search the web for documentation, blog posts, and release notes
2. Check their GitHub repos (if open source) for architecture and activity
3. Produce a structured analysis

Try these:

"How does [competitor] handle user onboarding?"
"Compare [competitor A] vs [competitor B] on pricing"
"What's [competitor]'s product strategy based on their recent releases?"

What you learned: Competitive research that would take half a day of Googling gets done in one conversation.

What You Built

By now you should have:

• An HTML deep-dive document in output/html/ or deep-dives/
• A competitor research file in output/competitor-research/

Both are real artifacts you can share with your team.

What's Next

You've gathered context and done research. Time to write. Head to Step 4: Write.

Step 4: Write — Generate Real Documents

This is the skill you'll use the most. The doc writer understands 7 PM document formats and picks the right one automatically.

Skills Used

• Doc Writer — Write product documents in any standard PM format

Exercise 1: Write a Concept One-Pager

Think of a new idea — something that doesn't exist yet. Say:

"Write a one-pager for [your idea]"

The AI will infer this is a Concept One-Pager (because it's a new idea) and write a narrative document with:

• Vision paragraph (problem → future state → benefits)
• Approach paragraph (how → user experience → outcomes)

What to notice: It didn't ask you which format — it inferred it from your request.

Exercise 2: Write a Problem/Solution One-Pager

Think of something broken or incomplete in your product. Say:

"Write a one-pager about improving [existing feature] to support [use case]"

The AI will detect this is a Problem/Solution One-Pager (existing feature, enhancement) and produce:

• Background & Context
• Problem (user + business perspective)
• Requirements (Given/When/Then)
• Things we DON'T need (explicit non-goals)

Exercise 3: Write a Decision Doc

Got a fork in the road? Say:

"Write a decision doc for choosing between [option A] and [option B]"

This produces a Decision One-Pager with a clear recommendation, options, tradeoffs, and kill criteria.

Exercise 4: Write a PRD

Need a full spec? Say:

"Write a PRD for [feature]"

This produces a comprehensive PRD / Structured Epic with problem statement, goals, requirements, work streams, success criteria, and architecture.

All 7 Formats

Pro Tip: Use Context From Earlier Steps

If you did a deep dive or competitor research earlier, reference it:

"Write a one-pager for [idea]. Use the competitor research from earlier as context."

The AI will weave in competitive insights and technical context from your earlier work.

What's Next

You have a draft. Time to get feedback before sharing it. Head to Step 5: Review.

Step 5: Review — Get Feedback Before the Meeting

Don't share a draft without reviewing it first. The doc reviewer gives you persona-based feedback that mimics the questions your CTO or GM would actually ask.

Skills Used

• Doc Reviewer — Format-aware, persona-aware document review

Exercise 1: CTO Review

Take the doc you wrote in Step 4 (or any doc you're working on). Say:

"Review this doc as a CTO"

The CTO review checks for:

• Feature fit — Does this belong in an existing product area, or are you creating unnecessary new surface?
• Green field fallacy — Are you building something new when it could integrate into what exists?
• Simplicity — Simple concepts lead to simple products. Is this simple enough?
• Phasing risk — Will incomplete phases create dangling work?

Exercise 2: GM Review

Say:

"Review this as a GM"

The GM review is based on Kent Beck's Explore/Expand/Extract framework and checks:

• Phase clarity — Is this Explore, Expand, or Extract work? Is the team explicit about which phase?
• Phase-appropriate behavior — Are you optimizing for learning (Explore) or efficiency (Extract)?
• Problem gravity — Does the problem stand on its own, independent of the solution?
• Adoption mechanics — Why would users choose this?

For Decision One-Pagers, the GM review shifts to decision execution mode:

• Is the decision stated unambiguously?
• Is the posture correct (FYI / Recommendation / Make the Call)?
• Are alternatives meaningfully different?
• What triggers a revisit?

Exercise 3: Review a Google Doc

Have a doc in Google Docs? Share the link:

"Review the doc at [Google Docs URL] as a CTO"

The AI will fetch the doc, detect its format, and apply persona-specific feedback.

Bonus — resolve comments:

"Review this doc and suggest how to resolve the comments: [URL]"

What You Learned

• CTO reviews catch architectural bloat and complexity
• GM reviews ensure you're operating correctly for your phase
• You can review docs from Google Docs links directly
• Review feedback is actionable — specific edits, not vague suggestions

What's Next

Your doc is reviewed and solid. Time to present it. Head to Step 6: Present.

Step 6: Present — Turn Work Into Shareable Artifacts

Two skills for two types of output: slide decks and polished reference pages.

Skills Used

• Presentation — Generate HTML slide decks
• HTML Reference Page — Generate styled, self-contained reference pages

Exercise 1: Build a Presentation

Take any topic you've been working on. Say:

"Create a presentation about [your topic]"

The AI will:

1. Ask about your goal (persuade, inform, update, propose) and audience
2. Propose a slide outline (typically 8-14 slides)
3. Wait for your approval
4. Generate a complete HTML slide deck

The output is a single HTML file with:

• Arrow key navigation
• Fullscreen mode
• Progress bar
• Print-to-PDF support
• Mobile swipe support

Open it in your browser and present directly — no PowerPoint needed.

Try referencing earlier work:

"Create a presentation about [topic] using the deep dive and competitor research from earlier"

Exercise 2: Build a Reference Page

For content that's better as a page than a deck — stats, architecture overviews, guides:

"Create a reference page for [topic]"

This produces a styled, self-contained HTML page with:

• Dark gradient header
• Card-based layout
• Data tables
• Source citations
• Print-friendly styling

Share it by sending the HTML file — anyone can open it in a browser.

What You Built

• A presentation in output/presentations/
• A reference page in output/html/

Both are real, shareable artifacts — not drafts, not mockups.

What's Next

You have the artifact. Time to ship it. Head to Step 7: Ship.

Step 7: Ship — Share With Stakeholders

Get your work out of the terminal and into the hands of your team.

Skills Used

• Google Docs — Write and sync documents to Google Docs
• Doc Writer — Publish directly to GitHub Issues

Exercise 1: Push a Doc to Google Docs

Take any markdown document you've created. Say:

"Export [document] to Google Docs"

The AI will:

1. Convert your markdown to a formatted Google Doc (with native tables, headings, etc.)
2. Return the Google Docs URL
3. Remind you to set Pageless mode for best formatting

The doc is private by default — share it manually via the Google Docs UI.

Exercise 2: Sync Changes Back

After collaborators edit the Google Doc, pull their changes:

"Show me what changed in the Google Doc since I last synced: [URL]"

This shows a diff. Then:

"Pull the latest from the Google Doc to my local file"

Or push your local changes:

"Push my local changes to the Google Doc"

Exercise 3: Publish to GitHub

Write a doc and publish it directly as a GitHub issue:

"Write an epic for [feature] and open it as an issue on [org/repo]"

The AI will:

1. Write the document in the appropriate format
2. Ask which repo to target (if not specified)
3. Create the issue with matching title format and labels
4. Return the issue URL

The Full Loop

At this point you've completed the full PM workflow:

1. Read — Pulled in context from calendar and docs
2. Research — Deep-dived a repo, researched competitors
3. Write — Generated a doc in the right format
4. Review — Got CTO/GM feedback
5. Present — Built a deck or reference page
6. Ship — Published to Google Docs or GitHub

That's the core loop. Everything after this is customization.

What's Next

Make it yours. Head to Step 8: Customize.

Step 8: Customize — Make It Yours

The core skills work out of the box. These two require your configuration to be truly useful.

Skills Used

• Morning Standup — Daily metric check-in
• My Initiatives — GitHub issue tracking

Exercise 1: Configure Your Morning Standup

Say:

"Help me configure my morning standup metrics"

The AI will ask:

1. What's your role? (PM, Engineering Lead, Executive)
2. What product areas do you focus on?
3. What questions do you want answered every morning?

Then it creates a metrics.yaml config file with your personalized metrics.

Example metrics you might configure:

Run it daily:

"Run my morning standup"

You get a red/yellow/green report of what needs your attention.

Bring your own data source

The standup works with any SQL-compatible data source. Configure your query runner in the metrics.yaml:

alerts:
  - name: "Feature Adoption"
    priority: high
    query: |
      SELECT COUNT(DISTINCT user_id) AS users
      FROM your_table
      WHERE date = CURRENT_DATE - 1
        AND feature_used = 'your_feature'
    milestone: "> 5000"
    target: 5000

Exercise 2: Configure Your Initiative Tracker

Say:

"Help me set up my initiative tracker"

The AI will ask:

1. Your GitHub username
2. Which repos to track
3. What labels to filter by
4. How to categorize your issues

Then it creates a config.yaml for the my-initiatives skill.

Sync your tasks:

"Sync my tasks from GitHub"

This pulls your assigned issues and organizes them into your tasks/ACTIVE.md file.

Browse your team's work:

"Show my team's epics"
"What needs PM input?"
"What's in the current release?"

Exercise 3: Add Your Own Skill

Want to add a workflow specific to your team? Create a new skill:

mkdir skills/my-custom-skill

Create skills/my-custom-skill/SKILL.md with this structure:

---
name: my-custom-skill
description: What this skill does. When to trigger it.
---

# My Custom Skill

## When to Use
- "trigger phrase one"
- "trigger phrase two"

## Process
1. Step one
2. Step two
3. Step three

The AI will pick it up automatically on next conversation.

You're Done

You now have:

• 10 working skills
• A daily standup configured for your role
• GitHub issues synced to your task list
• The ability to add your own skills

The workflow is:

1. Morning: Run standup, check calendar, sync GitHub tasks
2. During the day: Research, write, review, present — as needed
3. Ship: Push to Google Docs or GitHub when ready

Welcome to the Core AI PM Workflow.