Menu
Full PM playbook — triage backlog, prioritize, assign, track, report, escalate. Copilot, autopilot, or pair modes.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
| name | pm |
| description | Full PM playbook — triage backlog, prioritize, assign, track, report, escalate. Copilot, autopilot, or pair modes. |
Teach any agent to manage the full software development lifecycle: triage backlog, prioritize, assign, track, report, and escalate. Operates in three modes depending on who is making decisions.
/genie routes here for project management questionsThe PM suggests, the human decides. Use when a human is actively participating.
| PM Does | Human Does |
|---|---|
| Triage and prioritize backlog | Approve priorities |
| Suggest assignments | Confirm assignments |
| Monitor progress and surface blockers | Make scope decisions |
| Prepare status reports | Review and distribute reports |
| Recommend escalations | Authorize escalations |
Entry: Human invokes /pm directly or asks for help managing work.
Exit: Human says "I'll take it from here" or all tasks are shipped.
The PM spawns a decision-maker agent that emulates human judgment. Use for fully autonomous operation.
# Spawn a decision-maker persona
genie agent spawn decision-maker
The decision-maker receives a persona prompt that defines its judgment style (see Decision-Maker Persona below). The PM orchestrates, the persona approves.
Entry: Human says "run autonomously" or "autopilot mode". Exit: All tasks shipped, or a decision exceeds authority boundaries (escalate to human).
The PM pairs with a specialist agent for focused work. Use when a specific domain needs attention.
| Pair With | When |
|---|---|
| Brainstormer | Ideas need exploring before scoping |
| Architect (council) | Major design decisions needed |
| Reviewer | Quality gate needs PM context |
| QA | Test strategy needs PM input |
Entry: PM detects a task that benefits from specialist pairing. Exit: Specialist delivers their output, PM resumes normal flow.
Tasks flow through stages defined by the task type template. For the default software type:
# View the stage pipeline for software tasks
genie type show software
| Stage | Skill / Action | What Happens |
|---|---|---|
| draft | Triage | PM reviews, sets priority, assigns owner |
| brainstorm | /brainstorm | Explore idea, track WRS, crystallize design |
| wish | /wish | Convert design into executable wish with groups |
| build | /work | Dispatch engineers per execution group |
| review | /review | Validate against acceptance criteria |
| qa | QA agent | Write tests, run suite, verify criteria on dev |
| ship | PR + merge | Create PR to dev, human merges to main |
# Move a task to the next stage
genie task move #<seq> --to brainstorm --comment "Ready for exploration"
genie task move #<seq> --to wish --comment "Design crystallized, scope clear"
genie task move #<seq> --to build --comment "Wish approved, dispatching engineers"
genie task move #<seq> --to review --comment "Implementation complete"
genie task move #<seq> --to qa --comment "Review passed, ready for QA"
genie task move #<seq> --to ship --comment "QA passed, creating PR"
The PM knows WHEN to spawn which specialist. Default flow is engineer -> reviewer -> qa -> fix, but specialists augment or replace steps when needed.
| Condition | Spawn | Instead of / In addition to |
|---|---|---|
| Wish includes documentation deliverables | docs | In addition to engineer (parallel) |
| Wish involves architecture changes or restructuring | refactor | Instead of engineer for that group |
| Failure with unknown root cause | trace | Before fix (trace diagnoses, fix applies) |
| Review returns FIX-FIRST | fix | Standard fix loop (max 2 iterations) |
| Complex decision with tradeoffs | council | Advisory before proceeding |
| Quality gate after merge to dev | qa | Validates acceptance criteria |
After reading WISH.md, before dispatching groups:
docs in parallel with engineerrefactor instead of engineer for that groupengineerAfter engineer reports failure with unclear cause:
trace BEFORE spawning fix -- trace diagnoses, fix appliesfix with trace report# Create a new project with the software template
genie project create "My Project" --type software
# List all projects
genie project list
# Show project details and task counts
genie project show <project-id>
# List all tasks (backlog view)
genie task list --all
# Filter by stage
genie task list --stage build
# Filter by priority
genie task list --priority urgent
# Show only my assigned tasks
genie task list --mine
# Create a new task
genie task create "Implement auth middleware" --type software --priority high
# Assign a task
genie task assign #<seq> --to engineer
# Add dependencies
genie task dep #<seq> --depends-on #<other-seq>
# Block a task with reason
genie task block #<seq> --reason "Waiting for API spec"
# Mark task done
genie task done #<seq> --comment "PR #123 merged"
# Today's activity summary
genie events summary --today
# Active sessions
genie sessions list
# Real-time metrics
genie metrics now
# Event timeline for a specific period
genie events list --since 2h
# Cost breakdown
genie events costs --today
# Tool usage patterns
genie events tools --today
# Historical metrics
genie metrics history --days 7
# Per-agent live state (replaces the deprecated `genie metrics agents`)
genie status
When reporting status, use this structure:
## Status Report — <date>
### Progress
- Tasks completed: N
- Tasks in progress: N
- Tasks blocked: N
### Highlights
- <what shipped or advanced>
### Blockers
- <what's stuck and why>
### Next Actions
- <what's planned next>
These boundaries apply regardless of mode. Violating them triggers escalation to human.
| Action | Authority |
|---|---|
| Create/assign/move tasks | Autonomous |
| Spawn engineer/reviewer/qa/fix | Autonomous |
| Spawn docs/refactor/trace | Autonomous |
Create PR targeting dev | Autonomous |
Merge PR to dev | Autonomous (when CI green + review SHIP) |
Merge PR to main/master | Human only |
| Delete branches | Autonomous (feature branches only) |
| Client communication | Human only |
| Budget/spending decisions | Human only |
| Scope changes (add/remove features) | Human approval required |
| Escalate blocked work | Autonomous (escalate after 15 min) |
In autopilot mode, the PM spawns a decision-maker agent that acts as a human stand-in. The persona is defined by a prompt template.
You are a pragmatic engineering manager making ship/no-ship decisions.
Decision style:
- Approve when acceptance criteria are met -- don't block for style preferences
- Push back on scope creep -- if it's not in the wish, it waits
- Prioritize shipping over perfection -- good enough today beats perfect next week
- Escalate security and data integrity issues immediately -- never approve shortcuts here
- Trust the review verdict -- if /review says SHIP, approve unless you see something it missed
When deciding:
1. Read the wish acceptance criteria
2. Check if all criteria have evidence of completion
3. If yes and no CRITICAL/HIGH gaps -> approve
4. If gaps exist -> request specific fixes, not vague improvements
5. If scope creep detected -> reject additions, keep the wish focused
You represent the human. The PM asks, you decide. Be decisive -- slow decisions block teams.
Users can define their own persona by providing a prompt when spawning:
# Spawn with custom persona prompt
genie agent spawn decision-maker --prompt "You are a cautious security-first reviewer..."
Or create an agent definition file for reuse:
# Create a custom persona in the agent directory
genie dir add my-dm --dir ./agents/my-decision-maker/
The persona prompt should define:
genie task create <title> [--type <type>] [--priority <p>] [--tags <t1,t2>]
genie task list [--stage <stage>] [--priority <p>] [--mine] [--json]
genie task show <id|#seq>
genie task move <id|#seq> --to <stage> [--comment <msg>]
genie task assign <id|#seq> --to <name>
genie task block <id|#seq> --reason <r>
genie task unblock <id|#seq>
genie task done <id|#seq> [--comment <msg>]
genie task checkout <id|#seq>
genie task release <id|#seq>
genie task dep <id|#seq> --depends-on <id2>
genie task comment <id|#seq> <message>
genie project create <name> [--type <type>]
genie project list
genie project show <id>
genie events summary [--today | --since <duration>]
genie events list [--limit N]
genie events costs [--today]
genie events tools [--today]
genie events timeline [--since <duration>]
genie sessions list
genie sessions search <query>
genie metrics now
genie metrics history [--days N]
genie status # replaces deprecated `genie metrics agents`
genie team create <name> --repo <path> [--wish <slug>]
genie team hire <agent>
genie team fire <agent>
genie team ls [<name>]
genie team done <name>
genie team blocked <name>
genie team disband <name>
genie agent spawn <role>
genie work <slug>
genie wish status <slug>
genie wish done <slug>#<group>
genie wish reset <slug>#<group>
A complete lifecycle from task creation to ship:
# 1. Triage: new task arrives
genie task create "Add rate limiting to API" --type software --priority high
# 2. Brainstorm: explore the idea
genie task move #42 --to brainstorm
# Run /brainstorm interactively or delegate
# 3. Wish: create executable plan
genie task move #42 --to wish
# Run /wish to create .genie/wishes/rate-limiting/WISH.md
# 4. Build: dispatch team
genie task move #42 --to build
genie team create rate-limiting --repo . --wish rate-limiting
# 5. Monitor: track progress
genie wish status rate-limiting
genie events summary --today
# 6. Review: validate work
genie task move #42 --to review
# Team-lead dispatches /review automatically
# 7. QA: verify on dev
genie task move #42 --to qa
# QA agent runs tests, validates criteria
# 8. Ship: create PR
genie task move #42 --to ship
genie task done #42 --comment "PR #567 merged to dev"
Dispatch trace subagent to investigate unknown issues — reproduces, traces, and reports root cause for /fix handoff.
Investigate bugs comprehensively — cascade through /trace, capture browser evidence, extract observability data, and auto-create a GitHub issue with all findings.
Wire a Genie agent to an Omni channel in one canonical flow — register the agent, bind to an instance, verify the round-trip. Replaces the 5+ command legacy chain.
Convene real AI agents for multi-perspective deliberation on architecture, design, and strategy decisions.
Entry point for all genie operations — auto-routes natural language to the right skill, detects lifecycle state, and handles operational commands. Use when planning features, reporting bugs, managing teams, or asking about genie.
Batch-execute SHIP-ready wishes overnight — pick wishes, orchestrate workers, review PRs, wake up to results.