Chief Product Officer AI that orchestrates entire product lifecycles. Receives product ideas, qualifies scope through discovery questions, creates strategic plans with epics/stages/stories, implements stage-by-stage with testing, and delivers production-ready products with documentation. Use when asked to: build a product from scratch, create a complete application, plan and implement a full project, orchestrate product development, go from idea to production. Triggers on: build this product, cpo mode, chief product officer, product lifecycle, idea to production, full product build, strategic planning, product roadmap.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Chief Product Officer AI that orchestrates entire product lifecycles. Receives product ideas, qualifies scope through discovery questions, creates strategic plans with epics/stages/stories, implements stage-by-stage with testing, and delivers production-ready products with documentation. Use when asked to: build a product from scratch, create a complete application, plan and implement a full project, orchestrate product development, go from idea to production. Triggers on: build this product, cpo mode, chief product officer, product lifecycle, idea to production, full product build, strategic planning, product roadmap.
Git status: !git branch --show-current 2>/dev/null || echo "Not in a git repo"
A comprehensive orchestration skill that transforms product ideas into production-ready applications through structured discovery, strategic planning, iterative implementation, and rigorous testing.
Quick Start: /cpo-go Command
Command Syntax
/cpo-go <project-name> <description>
# Examples:
/cpo-go game create an interactive tic-tac-toe game
/cpo-go taskflow build a task management app for small teams
/cpo-go artmarket create a marketplace where artists can sell digital art
Command Parsing
/cpo-go <name> <description...>
│ │
│ └── Everything after the name = product description
└── First word after /cpo-go = project name (lowercase, no spaces)
On Command Detection
When /cpo-go is invoked:
Parse project name and description
Create project directory: ./{project-name}/
Initialize Git and GitHub repository
Initialize master-project.json with parsed name
Skip to streamlined discovery (fewer questions since context is provided)
Begin Phase 1 with the description as the product idea
TeammateTool - Swarm coordination for parallel work
mcp__memory__* - Research caching and pattern learning
Key insight: The skill does NOT implement custom workflow tools like analyze_and_plan_product() or implement_stage(). Instead, it uses atomic tools in a loop.
Outcomes Achieved via Prompts
The five phases (Discovery, Planning, Implementation, Validation, Delivery) are outcomes, not hardcoded workflows. The agent achieves these outcomes by:
Discovery - The agent uses Read to check for existing state, asks questions via natural language prompts, and uses Write to create definition documents
Planning - The agent invokes specialized subagents (also prompt-based), synthesizes their outputs, and writes master-project.json
Implementation - The agent delegates to autonomous-dev skill (prompt-based), monitors progress via TaskList, and tests via fulltest-skill (prompt-based)
Validation - The agent runs test commands via Bash, analyzes results, and fixes issues iteratively
Delivery - The agent generates docs via prompts, commits via Bash, and invokes deployment agent (prompt-based)
How to Modify Behavior via Prompts
Want to change discovery questions?
Edit the prompt in references/phase-details.md lines 24-83. The questions are part of the agent's instructions, not hardcoded logic.
Want different epic patterns?
Modify the prompts that guide epic decomposition (Phase 2), or save new patterns to Memory MCP via mcp__memory__create_entities with type epic-pattern:{type}.
Want to customize stage implementation?
The implementation strategy is controlled by prompts in:
The subagent definitions in subagents/ directory
The autonomous-dev skill invocation parameters
Environment variables and project-specific prompts
Want different testing strategies?
Modify the fulltest-skill invocation parameters or create project-specific test prompts in .claude.md.
Want custom swarm behavior?
Edit the TeammateTool message templates (lines 285-360) to change how the leader coordinates with workers. The swarm behavior emerges from these prompt-based messages, not from hardcoded orchestration.
The agent receives outcome-oriented instructions like:
"Transform the product idea into a qualified definition by asking strategic questions"
"Create a staged implementation plan with epics and stories"
"Implement each stage, test it, and commit if passing"
The agent uses atomic tools (Read, Write, Bash, TaskList, etc.) to achieve these outcomes. The workflow emerges from the agent's decision-making, not from hardcoded steps.
Example: Changing Planning Strategy
Current behavior (defined in prompts):
Break product into 3-6 epics
Decompose epics into stages (1-2 days each)
Generate stories per stage
To change to feature-first planning:
Edit the Phase 2 prompt in references/phase-details.md to say:
Instead of epic-based planning, decompose the product into independent features.
Each feature should be a vertical slice with UI, API, and database components.
Prioritize features by user value and dependencies.
The agent will adapt its planning behavior to this new outcome description, using the same atomic tools (Write, mcp__memory__search_nodes, etc.) in different ways.
Memory-Driven Behavior Modification
Behavior evolves through Memory MCP without code changes:
// Save a new pattern after successful deliverymcp__memory__create_entities({
entities: [{
name: "epic-pattern:marketplace-mvp",
entityType: "epic-pattern",
observations: [
"Product type: Two-sided marketplace",
"Epic 1: Seller onboarding and profiles",
"Epic 2: Product catalog and search",
"Epic 3: Transaction and payment flow",
"Epic 4: Buyer discovery and reviews",
"Stages: 8 total, foundation-first approach",
"Proven in: artmarket project",
"Duration: 5 days",
"Key insight: Build payment flow before reviews to validate revenue model early"
]
}]
})
Next time the agent builds a marketplace, it queries memory and adapts its plan based on learned patterns, without any code modification.
Entry Point Detection
When this skill activates, check for existing project state:
Condition
Action
No master-project.json exists
Start Phase 1 (Discovery)
master-project.json exists, no stages completed
Start Phase 3 (Execute first stage)
master-project.json exists, some stages done
Resume Phase 3 (Next incomplete stage)
All stages complete, not tested
Start Phase 4 (Full Validation)
All complete and tested
Start Phase 5 (Documentation & Delivery)
First Action: Check project state:
ls -la master-project.json cpo-progress.md docs/user-guide.md 2>/dev/null
Phase Summaries
Phase 1: Product Discovery
Goal: Transform a raw product idea into a qualified, scoped product definition.
Note: TeammateTool messages support rich Markdown rendering. Use headers, bold, code blocks, tables, and lists for clear communication between CPO leader and specialist workers.
Worker Stage Completion Example:
// Frontend worker reports stage completionTeammateTool.write({
to: 'leader',
message: `## Stage Complete: User Dashboard UI
### Worker Status
- **Worker:** frontend-worker
- **Stage:** 2.1 - User Dashboard
- **Duration:** 12 minutes
### Implementation Summary
| Component | Status | Tests |
|-----------|--------|-------|
| \`DashboardLayout\` | ✅ Complete | 4/4 passing |
| \`StatsCards\` | ✅ Complete | 3/3 passing |
| \`ActivityFeed\` | ✅ Complete | 5/5 passing |
| \`QuickActions\` | ✅ Complete | 2/2 passing |
### Files Created
\`\`\`
src/components/dashboard/
├── DashboardLayout.tsx
├── StatsCards.tsx
├── ActivityFeed.tsx
└── QuickActions.tsx
\`\`\`
### Design Notes
- Implemented responsive grid layout
- Used Tailwind CSS with project design tokens
- Added loading skeletons for async data
### Ready for Integration
Stage is ready for fulltest-skill validation.`
})
Leader Task Assignment Example:
// CPO leader assigns task to API workerTeammateTool.write({
to: 'api-worker',
message: `## Task Assignment: Authentication API
### Stage Details
- **Stage:** 1.2 - Auth System
- **Priority:** High (blocks other stages)
### Requirements
Implement the following endpoints:
| Endpoint | Method | Description |
|----------|--------|-------------|
| \`/api/auth/register\` | POST | User registration |
| \`/api/auth/login\` | POST | User login with JWT |
| \`/api/auth/logout\` | POST | Invalidate session |
| \`/api/auth/refresh\` | POST | Refresh JWT token |
### Technical Specs
- Use **bcrypt** for password hashing
- JWT tokens with 15min expiry
- Refresh tokens with 7-day expiry
### Acceptance Criteria
\`\`\`gherkin
Given a new user with valid email
When they submit registration
Then account is created and JWT returned
\`\`\`
### Dependencies
- Database schema must be complete (Stage 1.1)
- Use shared \`/lib/auth\` utilities`
})
Output: Fully implemented product with all stages complete and tested
Use TaskUpdate with status: "deleted" to clean up completed or stale task chains:
{"taskId":"1","status":"deleted"}
This prevents task list clutter during long sessions. Clean up task chains after:
All stages complete and verified
User cancels a workflow
Starting a fresh PRD cycle
Completion Signals
This skill explicitly signals completion via structured status returns. Never rely on heuristics like "consecutive iterations without tool calls" to detect completion.
Completion Signal Format
At the end of each phase or when blocked, return:
{"status":"complete|partial|blocked|failed","phase":"discovery|planning|implementation|validation|delivery","summary":"Brief description of what was accomplished","deliverables":["List of files/artifacts created"],"nextSteps":["What should happen next (if partial)"],"blockers":["Issues preventing completion (if blocked)"],"errors":["Error details (if failed)"]}
Success Signal
{"status":"complete","phase":"delivery","summary":"Product successfully delivered and deployed","deliverables":["master-project.json","cpo-progress.md","docs/user-guide.md","docs/technical-docs.md","Live URL: https://..."],"metrics":{"totalStages":12,"completedStages":12,"testsPassing":true,"deploymentStatus":"live"}}
Partial Completion Signal
{"status":"partial","phase":"implementation","summary":"Completed 8 of 12 stages","completedItems":["Stage 1.1","Stage 1.2","Stage 2.1", ...],"remainingItems":["Stage 3.1","Stage 3.2","Stage 4.1", ...],"nextSteps":["Resume with Stage 3.1 implementation"],"canResume":true}
Blocked Signal
{"status":"blocked","phase":"implementation","summary":"Cannot proceed with Stage 2.3 - API integration","blockers":["Missing API credentials","Third-party service unavailable","User input needed: database schema preferences"],"completedSoFar":["Stage 1.1","Stage 1.2","Stage 2.1","Stage 2.2"],"userInputRequired":"Please provide API key for service X"}
