Agent skill

pm

Full PM playbook — triage backlog, prioritize, assign, track, report, escalate. Copilot, autopilot, or pair modes.

View SKILL.md on GitHub Repository
Stars 280
Forks 46

Install this agent skill to your Project

npx add-skill https://github.com/automagik-dev/genie/tree/main/skills/pm

SKILL.md

/pm — Project Management Playbook

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.

When to Use

  • Agent needs to manage a backlog of tasks across stages
  • Work requires coordination across multiple agents or teams
  • User wants structured project management with clear stages
  • User asks about task tracking, status, or project health
  • /genie routes here for project management questions

Three Modes

Copilot Mode (PM + Human)

The 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.

Autopilot Mode (PM + Decision-Maker Persona)

The PM spawns a decision-maker agent that emulates human judgment. Use for fully autonomous operation.

bash
# 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).

Pair Mode (PM + Specialist Agent)

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.

Stage-to-Skill Mapping

Tasks flow through stages defined by the task type template. For the default software type:

bash
# 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

Moving Tasks Through Stages

bash
# 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"

Agent Routing

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

Decision Points

After reading WISH.md, before dispatching groups:

  1. Check wish scope for docs deliverables -> spawn docs in parallel with engineer
  2. Check wish scope for "refactor" or "restructure" keywords -> spawn refactor instead of engineer for that group
  3. Default: spawn engineer

After engineer reports failure with unclear cause:

  1. Spawn trace BEFORE spawning fix -- trace diagnoses, fix applies
  2. If trace finds root cause -> dispatch fix with trace report
  3. If trace cannot determine cause -> escalate as BLOCKED

Board Management

Setting Up a Project Board

bash
# 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>

Board Operations

bash
# 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"

Status Reporting

Quick Status

bash
# Today's activity summary
genie events summary --today

# Active sessions
genie sessions list

# Real-time metrics
genie metrics now

Detailed Status

bash
# 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 metrics
genie metrics agents

Status Report Template

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>

Authority Boundaries

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)

Decision-Maker Persona

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.

Default Persona: Pragmatic Engineering Manager

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.

Customizing the Persona

Users can define their own persona by providing a prompt when spawning:

bash
# 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:

bash
# Create a custom persona in the agent directory
genie dir add my-dm --dir ./agents/my-decision-maker/

The persona prompt should define:

  • Decision style -- what to approve, what to reject
  • Priority framework -- how to weigh competing concerns
  • Escalation triggers -- when to defer to a human instead of deciding

CLI Quick Reference

Task Management

bash
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>

Project Management

bash
genie project create <name> [--type <type>]
genie project list
genie project show <id>

Observability

bash
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 metrics agents

Team Operations

bash
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>

Agent Dispatch

bash
genie agent spawn <role>
genie work <slug>
genie task status <slug>
genie task done <slug>#<group>
genie reset <slug>#<group>

PM Workflow Example

A complete lifecycle from task creation to ship:

bash
# 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 task 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"

Rules

  • Never write code -- delegate all implementation to engineers via team-leads
  • Never merge to main/master -- only humans do that
  • Never skip QA -- every wish gets validated before shipping
  • Never hide blockers -- report early and transparently
  • Never create speculative tasks -- only track real, concrete work
  • Escalate within 15 minutes if blocked -- stalled PMs cascade to team-wide delays
  • Match the mode to the situation -- copilot when human is present, autopilot for overnight, pair for specialist work

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

automagik-dev/genie

genie

Single entry point for all genie operations — auto-routes natural language to the right skill, detects existing lifecycle state, and handles operational commands. Use when planning features, reporting bugs, managing teams, or asking about the system.

280 46
Explore
automagik-dev/genie

refine

Transform a brief or prompt into a structured, production-ready prompt via prompt-optimizer. File or text mode.

280 46
Explore
automagik-dev/genie

work

Execute an approved wish plan — orchestrate subagents per task group with fix loops, validation, and review handoff.

280 46
Explore
automagik-dev/genie

review

Validate plans, execution, or PRs against wish criteria — returns SHIP / FIX-FIRST / BLOCKED with severity-tagged gaps.

280 46
Explore
automagik-dev/genie

wish

Convert an idea into a structured wish plan with scope, acceptance criteria, and execution groups for /work.

280 46
Explore
automagik-dev/genie

learn

Diagnose and fix agent behavioral surfaces when the user corrects a mistake — connects to Claude native memory.

280 46
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results