product-playbook-for-agentic-coding

Create a new branch and worktree together for isolated development

Analyze git changes and create well-structured conventional commits

Create a pull request with clear title and description using GitHub CLI

Create a git worktree for isolated parallel development

Safely delete a git branch from local and remote after verification

Move uncommitted changes to a new branch without committing

Test command to verify plugin installation is working correctly

List all commands and help you choose the right one for your task

Run parallel multi-persona critiques on documents with versioning and synthesis

Debug CI/CD failures systematically using GitHub CLI

Systematic debugging workflow with verification-first approach

Facilitate a design critique to analyze visual designs and inform product decisions

Create a high-fidelity design specification for complex UI features

Extract or create a canonical DESIGN.md from Stitch screens, codebase tokens, or guided interview

Transform Stitch screen HTML into project component scaffolds matching your codebase architecture

Compare running implementation against Stitch mockups and produce a visual diff report

Create focused summaries or quick references from longer documents, optimized for a specific purpose.

Build strategy foundations that anchor all downstream product decisions. Creates Mission, Vision, Personas, and Engagement frameworks.

Identify top improvements from an agentic coding session for continuous improvement

Analyze coding sessions to identify patterns, compare against existing playbook capabilities, and implement improvements as a PR.

Capture learnings to improve docs and workflows

Batch-generate Stitch screens from prompts with automatic design consistency enforcement

Organize project files into logical subdirectories based on content analysis

Draft product requirements with multi-persona discovery process. Supports autonomous and interview modes.

Get real-time coaching on your prompts to improve agentic coding effectiveness

Incorporate new information or feedback into existing documents while maintaining consistency across related docs.

Synthesize research from multiple sources into strategic opportunities. Combines quantitative, qualitative, and product taste insights.

Review a project's readiness for autonomous agentic execution

Systematically review and optimize the playbook/plugin using a scoring rubric

Generate a document based on a spec file with rubric/excellence criteria. Searches context directories and produces a cited draft.

Run quality rubrics against code to validate implementation quality

Break down work into specific, actionable tasks

Create technical plan with architecture and sequencing

Work autonomously on multiple tasks without interruption

Execute the next task from the tasks document

Use this agent to validate consistency across interconnected documents. Checks that linked concepts match, definitions align, and cross-references are accurate. <example>\nContext: User has a set of interconnected documentation.\nuser: "Can you check if my foundations docs are consistent with each other?"\nassistant: "I'll use the cross-reference-validator-agent to check all cross-references and verify consistency."\n<commentary>\nSince the user has interconnected documents and wants consistency checking, use the cross-reference-validator-agent.\n</commentary>\n</example>\n<example>\nContext: User just updated one document and wants to ensure it didn't break references.\nuser: "I updated the personas doc - did that break anything?"\nassistant: "Let me launch the cross-reference-validator-agent to check if any documents reference the changed content."\n<commentary>\nAfter document updates, use cross-reference-validator-agent to catch cascading inconsistencies.\n</commentary>\n</example>

Use this agent for systematic debugging with a verification-first approach. This agent helps diagnose issues by first reproducing the problem, then forming and testing hypotheses. <example>\nContext: User encounters an error or unexpected behavior.\nuser: "The API is returning 500 errors intermittently"\nassistant: "I'll use the debugging-agent to systematically investigate this issue"\n<commentary>\nIntermittent errors need systematic debugging to isolate the root cause.\n</commentary>\n</example>\n<example>\nContext: Something stopped working after a change.\nuser: "The notification feature broke after the latest deploy"\nassistant: "Let me launch the debugging-agent to trace what changed and identify the cause"\n<commentary>\nRegression after deploy benefits from systematic debugging approach.\n</commentary>\n</example>

Use this agent for the Delivery phase when executing tasks from a tasks document. This agent works through tasks systematically with quality checks, progress tracking, and incremental commits. <example>\nContext: Tasks are defined, ready to execute.\nuser: "Let's start working on the notification feature tasks"\nassistant: "I'll use the delivery-agent to work through the tasks systematically"\n<commentary>\nWith tasks defined, use the delivery-agent to execute them with proper quality gates.\n</commentary>\n</example>\n<example>\nContext: User wants to continue work on existing tasks.\nuser: "What's the next task to work on?"\nassistant: "Let me launch the delivery-agent to identify and execute the next pending task"\n<commentary>\nThe delivery-agent manages task execution workflow including identifying what's next.\n</commentary>\n</example>

Use this agent to extract and organize insights from source materials (interview notes, research docs, meeting notes) with proper citations. Produces a structured insights document with source links. <example>\nContext: User has interview notes and wants to extract product insights.\nuser: "I have interview notes in interviews/ - can you extract the key product insights?"\nassistant: "I'll use the insight-extractor-agent to systematically extract and categorize insights from your interview notes."\n<commentary>\nSince the user has source materials and wants organized insights, use the insight-extractor-agent to search, extract, and cite.\n</commentary>\n</example>\n<example>\nContext: User wants to find all mentions of a topic across documents.\nuser: "What have stakeholders said about pricing across all our meeting notes?"\nassistant: "Let me launch the insight-extractor-agent to find and organize all pricing-related insights from your meeting notes."\n<commentary>\nThe user needs targeted extraction across multiple documents, which is the core use case for insight-extractor-agent.\n</commentary>\n</example>

Autonomous Chat Insights Pipeline agent that analyzes chat sessions, brainstorms product improvements, RICE-scores ideas, and generates a morning report. This is a reference for interactive ad-hoc runs — the automated pipeline uses runner.ts directly.

Use this agent to analyze coding sessions and identify patterns that could become new playbook tools. Performs gap analysis against existing playbook capabilities. <example>\nContext: User wants to improve the playbook based on their usage patterns.\nuser: "Analyze my recent sessions and find patterns that should be playbook tools"\nassistant: "I'll use the playbook-improvement-agent to analyze your sessions and identify gaps in the playbook."\n<commentary>\nSince the user wants to improve the playbook from session patterns, use the playbook-improvement-agent for analysis.\n</commentary>\n</example>\n<example>\nContext: User encountered friction with the playbook and wants to improve it.\nuser: "I keep doing the same thing manually - can we add a command for it?"\nassistant: "Let me use the playbook-improvement-agent to analyze what you've been doing and propose a new command."\n<commentary>\nThe user has identified a repeated pattern manually, which is a clear signal for playbook-improvement-agent to analyze and propose a solution.\n</commentary>\n</example>

Use this agent to autonomously draft a Product Requirements Document from available context. Optimized for creating agent-ready PRDs that enable autonomous technical planning and implementation. <example>\nContext: User has existing research and wants a PRD drafted.\nuser: \"Draft a PRD from the research in projects/feature-x/\"\nassistant: \"I'll use the prd-drafting-agent to analyze your research and draft a comprehensive PRD.\"\n<commentary>\nSince the user has context and wants autonomous drafting, use the prd-drafting-agent.\n</commentary>\n</example>\n<example>\nContext: User has a brief idea and wants to skip the interview process.\nuser: \"I need a PRD for adding dark mode - just draft it based on what you know about our codebase\"\nassistant: \"I'll use the prd-drafting-agent to search the codebase for context and draft a PRD for dark mode.\"\n<commentary>\nThe user wants autonomous drafting without discovery questions, which is the prd-drafting-agent's specialty.\n</commentary>\n</example>

Use this agent for the Product Discovery phase when defining WHAT to build and WHY. This agent facilitates multi-persona exploration of product requirements, user needs, and success criteria. <example>\nContext: Starting a new feature or project.\nuser: "I want to add user notifications to the app"\nassistant: "I'll use the product-discovery-agent to help define what kind of notifications, for whom, and why"\n<commentary>\nSince the user is starting a new feature without clear requirements, use the product-discovery-agent to facilitate discovery.\n</commentary>\n</example>\n<example>\nContext: User has a vague feature idea.\nuser: "We need something to help users track their progress"\nassistant: "Let me launch the product-discovery-agent to explore what progress tracking means for your users"\n<commentary>\nVague requirements benefit from structured discovery using multiple perspectives.\n</commentary>\n</example>

Use this agent for the Solution Planning phase when designing HOW to build a feature. This agent creates technical plans with architecture decisions, implementation sequences, and risk assessment. Requires product requirements as input. <example>\nContext: Product requirements are defined, ready to plan implementation.\nuser: "The PRD is complete, let's plan how to build the notification system"\nassistant: "I'll use the solution-planning-agent to design the technical architecture and implementation plan"\n<commentary>\nWith requirements defined, use the solution-planning-agent to create a technical plan.\n</commentary>\n</example>\n<example>\nContext: User wants to understand implementation approach.\nuser: "How should we architect the caching layer?"\nassistant: "Let me launch the solution-planning-agent to explore architectural options and create a plan"\n<commentary>\nArchitectural decisions benefit from structured planning with multiple perspectives.\n</commentary>\n</example>

Patterns for autonomous project execution with minimal human intervention. Use this skill when executing well-defined tasks autonomously, including validation strategies, stop conditions, and quality gates.

Patterns for analyzing chat sessions to extract product insights. Covers session sampling, evidence validation, idea deduplication, PII handling, data quality assessment, and prompt injection defense.

Patterns for finding and using project documentation at runtime. Use this skill when you need to search for existing documentation, solutions, patterns, or learnings in a codebase before starting work.

Multi-trigger, dual-target learning capture patterns. Use this skill to understand how to capture learnings at different points in the development workflow and route them to appropriate targets (codebase docs or plugin improvements).

Patterns for debugging mobile-specific issues on iOS Safari and Android Chrome. Use this skill when encountering viewport, keyboard, or touch-related bugs that only reproduce on real mobile devices.

Persist working context across sessions and context compaction events. Write checkpoints at session end, read at session start. Prevents re-orientation tax from context amnesia.

Shared patterns and best practices for Google Stitch MCP integration. Referenced by all design pipeline commands (design-system, design-spec, mockups, design-critique, design-to-code, design-verify).

Patterns for defining and executing end-to-end user journeys via browser automation at major milestones. Catches integration bugs that component tests miss.