CHAPTERS
- 0:00 – 4:11
Living in Claude Code: the promise of end-to-end PM workflows
Carl and Aakash set the stage: Claude Code is becoming a place PMs can live all day, not just a chatbot. They preview an advanced masterclass focused on connecting tools, automating repeatable work, and building systems rather than one-off prompts.
- •Claude Code as a “single workspace” for PM tasks
- •Why advanced usage is about systems/workflows, not individual prompts
- •Preview: MCP connections, Skills, and GitHub automation
- •PM work is largely document-centric (Drive/Notion/Confluence)
- •Goal: reduce context-switching and manual UI clicking
- 4:11 – 8:29
Why Claude Code scaled so fast: depth for power users vs generalist tools
They unpack the reported $1B ARR milestone and why Claude Code keeps winning despite competition. The thesis: Anthropic focuses on deep work/coding workflows, creating highly retained power users, while competitors emphasize general or multimodal capabilities.
- •OpenAI as generalist; Google as multimodal leader; Anthropic as work/coding specialist
- •Claude Code’s “addictive” depth: more tasks stay inside one tool
- •Competitors often copy Claude Code’s already-shipped features
- •MCP as an open standard accelerant for ecosystem adoption
- •Skills emerging as another standard others start to emulate
- 8:29 – 11:04
Productivity gap: turning repeated tasks into reusable workflows (rules/files)
Carl explains why some users feel Claude Code is slow or unproductive: they operate step-by-step instead of codifying repeatable workflows. Advanced users identify recurring tasks, define rules/templates/files, and then run them in one shot.
- •Beginner pattern: ‘do this… now do this…’ vs workflow-first thinking
- •Define rules/templates so Claude can execute end-to-end
- •Use files as durable context and process definitions
- •Think in terms of a ‘system’ you’re building with Claude
- •Opus 4.5’s autonomy: keep going, unblock itself, validate progress
- 11:04 – 17:37
MCP fundamentals: connecting Claude Code to external tools (Linear demo setup)
They introduce Model Context Protocol (MCP) as the standard way to connect Claude Code to services like Linear, Google Workspace, Slack, and more. Carl shows how to install an MCP server via a terminal command, authenticate, and immediately gain tool actions inside Claude Code.
- •MCP = standard for LLM-to-service connectivity; install often via one command
- •Restart Claude Code to pick up MCP configuration changes
- •Authentication flow is required (browser approval)
- •Inspecting MCP tools reveals many available actions automatically
- •Demo goal: create real issues in Linear from Claude Code
- 17:37 – 20:09
Essential MCP stack for PMs + context window tradeoffs
They expand from Linear to what PMs should connect: document systems, support, analytics, CRM, and research tooling. Carl highlights a practical tradeoff: enabling many MCPs can consume context window, so toggle them intentionally.
- •High-impact MCPs: Google Drive/Workspace, Notion, Confluence, Slack
- •PM-critical integrations: Intercom/Zendesk, Dovetail, Salesforce, analytics tools
- •Mindset: always ask ‘does this tool have an MCP?’
- •Toggle MCPs on/off to manage context usage
- •Claude can suggest enabling a relevant MCP when it’s disabled
- 20:09 – 21:28
API vs MCP: when scripts still matter (and why)
Carl distinguishes MCP integrations from direct API calls. MCPs come with structured tools Claude already understands; APIs require more guidance and usually a script, but unlock access even when no MCP exists.
- •MCP gives a ready-made toolset; API requires instructions + code
- •APIs are ideal when no MCP exists or for specialized capabilities
- •Claude can write the script once; then reuse it as part of workflows
- •Two connectivity patterns: standardized tools vs custom integration code
- •Sets up later image generation and automation examples
- 21:28 – 24:38
End-to-end PM workflow kickoff: survey creation → Google Docs publishing
They begin the fictional ‘Taskflow’ calendar integration project with user research. Claude generates a survey from local context files, saves it as markdown, and pushes it to Google Docs—illustrating a ‘create locally, publish externally’ workflow.
- •Project narrative: Taskflow to-do app adding calendar integration
- •Claude writes survey using a template + feature context file(s)
- •Google Workspace MCP publishes output directly to Drive/Docs
- •Pro tip: Google Docs ‘paste from markdown’ for clean formatting
- •Foundation for downstream synthesis, PRD, deck, and tickets
- 24:38 – 33:13
Survey response ingestion & synthesis: Skills concept and reliability caveats
They pull survey responses into Claude Code and attempt to synthesize insights. This becomes a practical lesson in Skills: how they’re meant to auto-trigger on certain tasks, and how in practice you may need to explicitly call the skill to ensure consistent behavior.
- •Pull responses without analysis first, then synthesize separately
- •Skills = reusable, structured templates that should auto-trigger
- •Reality: auto-invocation can be inconsistent; explicit prompting helps
- •Queueing messages lets you chain steps while Claude works
- •Model choice affects speed (Sonnet/Haiku for lighter tasks)
- 33:13 – 37:08
Building a Skills library: GitHub skills, marketplaces (plugins), and safety
They show multiple ways to acquire and manage Skills: copy from GitHub repos, use plugin marketplaces, or create your own. They also warn about prompt injection when importing third-party skills, especially with ‘dangerously skip permissions’ enabled.
- •Sources: shared GitHub skill repos, trusted newsletters, plugin marketplace
- •Plugin install example: Anthropic ‘document skills’ pack
- •Skills include helpers like ‘skill creator’ and document generation tools
- •Security: prompt injection risk—vet skills before use
- •Practical usage: skills for podcast production, writing/editing, takeaways
- 37:08 – 44:07
Image generation via Gemini API inside Claude Code (env keys + script workflow)
Carl demonstrates using an API (Gemini/NanoBanana) from Claude Code to generate images, explaining why code-based workflows beat UI-only prompting. They cover .env key hygiene, script reuse, and how a new skill could wrap image generation into a repeatable PM artifact workflow.
- •Store API keys in .env; rely on .gitignore to prevent leaks
- •Claude can generate prompts and call image API from a script
- •Benefits: brand/style files, reusable prompt patterns, parallel variants
- •Idea: create a dedicated ‘NanoBanana prompting’ or image skill
- •Claude validates output and can self-check more effectively with Opus
- 44:07 – 50:22
From research to PRD: drafting and publishing a requirements doc to Google Docs
They convert synthesized survey insights into a PRD, again publishing it to Google Docs via MCP. The discussion emphasizes how templates and skills can standardize PRD structure and reduce repeated searching for ‘the latest good example.’
- •Claude reads survey synthesis and generates a structured PRD
- •Google Docs publishing as the shareable ‘source of truth’
- •PRD includes research evidence + requirements and rationale
- •Tip: add persistent info (like email) to claude.md for MCP defaults
- •Next step tees up visuals (user journey map) and stakeholder comms
- 50:22 – 50:50
Deck generation from PRD: document skills create real editable slides
They use Anthropic’s document skills to generate a full presentation from the PRD—producing real, editable slides rather than static images. Carl notes that explicitly instructing Claude to use the presentation skill improves reliability, and highlights Claude Code’s parallel sub-agent execution.
- •Using document skills: PowerPoint/Slides generation via Claude Code
- •Outcome: editable slide objects (not screenshots) with layout/design
- •Parallel slide creation via sub-agents speeds generation vs UI Claude
- •Best practice: explicitly call the presentation skill when needed
- •Future improvement: visual feedback loops (Playwright/Puppeteer) for iteration
- 50:50 – 58:36
Hooks feature: automating actions around tool use and long tasks (notification example)
Carl introduces Hooks—automation triggers at different stages of a Claude Code session (start/end, tool use, compaction, etc.). They attempt a Mac notification hook for task completion, discuss practical hook ideas, and acknowledge live-demo debugging realities.
- •Hooks trigger on events: session start/end, before/after tool use, compaction
- •Use case: notifications for long-running tasks like deck generation
- •More advanced ideas: auto-run tests, auto-export chat before compaction
- •Hooks enable ‘tight control’ workflows for repeatability and QA
- •Reality: setup may require debugging; feature still evolving
- 58:36 – 1:08:08
PRD refinement and ticket creation: auto-generate prioritized Linear issues
After incorporating stakeholder meeting notes, Claude generates a full set of engineering tickets directly in Linear with priorities and structured acceptance criteria. They stress that ticket quality tracks PRD specificity, and that connecting to a codebase could further deepen technical detail.
- •Update PRD with stakeholder constraints (e.g., compliance/SSO)
- •Create engineering tickets from PRD directly into Linear via MCP
- •Tickets include overview, requirements, technical considerations, acceptance criteria
- •Automatic prioritization (P1/P2) based on PRD content
- •Better PRD context and codebase access yield more technical tickets
- 1:08:08 – 1:20:34
GitHub integration & ‘remote worker’ mode: @Claude on issues, plus Git basics for PMs
They show how syncing a repo to GitHub enables Claude to work asynchronously via GitHub issues—useful when you’re away from your computer. Carl explains pull/push/branch/merge at a PM-friendly level and frames GitHub as a simple, powerful file store that Claude is ‘fiercely competent’ with.
- •Sync local work to GitHub so it’s accessible anywhere
- •Install/configure Claude GitHub app and trigger work via @claude on issues
- •Remote use case: capture a requirement on mobile; Claude updates repo before you return
- •Git basics: pull = download, push = upload; branches for safe changes; merge to main
- •Wrap-up mindset: keep experimenting; workflows compound over time
