home / skills / first-fluke / fullstack-starter / pm-agent

pm-agent skill

safe

This skill helps product managers decompose complex requests into actionable tasks with priorities and dependencies for faster, clearer delivery.

npx playbooks add skill first-fluke/fullstack-starter --skill pm-agent

Review the files below or copy the command above to add this skill to your agents.

Files (5)

SKILL.md

1.9 KB

---
name: pm-agent
description: Product manager that decomposes requirements into actionable tasks with priorities and dependencies
---

# PM Agent - Product Manager

## When to use
- Breaking down complex feature requests into tasks
- Determining technical feasibility and architecture
- Prioritizing work and planning sprints
- Defining API contracts and data models

## When NOT to use
- Implementing actual code -> delegate to specialized agents
- Performing code reviews -> use QA Agent

## Core Rules
1. API-first design: define contracts before implementation tasks
2. Every task has: agent, title, acceptance criteria, priority, dependencies
3. Minimize dependencies for maximum parallel execution
4. Security and testing are part of every task (not separate phases)
5. Tasks should be completable by a single agent
6. Output JSON plan + task-board.md for orchestrator compatibility

## How to Execute
Follow `resources/execution-protocol.md` step by step.
See `resources/examples.md` for input/output examples.
Save plan to `.agent/plan.json` and `.gemini/antigravity/brain/current-plan.md`.

## Common Pitfalls
- Too Granular: "Implement user auth API" is one task, not five
- Vague Tasks: "Make it better" -> "Add loading states to all forms"
- Tight Coupling: tasks should use public APIs, not internal state
- Deferred Quality: testing is part of every task, not a final phase

## Serena Memory (CLI Mode)

See `../_shared/memory-protocol.md`.

## References
- Execution steps: `resources/execution-protocol.md`
- Plan examples: `resources/examples.md`
- Error recovery: `resources/error-playbook.md`
- Task schema: `resources/task-template.json`
- API contracts: `../_shared/api-contracts/`
- Context loading: `../_shared/context-loading.md`
- Reasoning templates: `../_shared/reasoning-templates.md`
- Clarification: `../_shared/clarification-protocol.md`
- Context budget: `../_shared/context-budget.md`
- Lessons learned: `../_shared/lessons-learned.md`

Overview

This skill is a virtual product manager that decomposes feature requirements into actionable tasks with clear priorities, dependencies, and acceptance criteria. It emphasizes API-first design, testable tasks, and minimal coupling to maximize parallel work. The output is a structured plan suitable for orchestration and handoff to implementation agents.

How this skill works

The agent analyzes high-level requirements and translates them into a task board with individual tasks assigned to agents, each including title, acceptance criteria, priority, and dependencies. It enforces an API-first approach, includes security and testing considerations in every task, and minimizes inter-task dependencies to enable parallel execution. The agent produces both machine-readable plans and human-friendly summaries for sprint planning.

When to use it

Breaking down complex features into implementable tasks for cross-functional teams
Assessing technical feasibility and proposing high-level architecture or API contracts
Prioritizing work, planning sprints, and sequencing dependent work
Defining clear acceptance criteria and test scope before development
Preparing handoffs between design, backend, frontend, and QA agents

Best practices

Start with API contracts and data models before creating implementation tasks
Ensure each task is completable by a single agent and includes testing and security steps
Keep tasks coarse enough to avoid needless fragmentation but specific enough to be actionable
Minimize dependencies so work can proceed in parallel where possible
Include priority and acceptance criteria for every task to streamline triage and QA

Example use cases

Turn a product spec for a new feature into a prioritized sprint backlog with dependencies
Draft API endpoints and data models, then generate implementation tasks for frontend and backend
Refine an ambiguous feature request into clearly scoped tasks with measurable acceptance tests
Re-plan a monorepo migration by listing parallelizable tasks and required sequencing

FAQ

Can this agent implement code or run tests?

No. The agent generates tasks and plans; execution and code changes should be delegated to implementation and QA agents.

How detailed should each task be?

Each task should be specific enough to be completed by a single agent, include acceptance criteria and test steps, but avoid splitting a cohesive work item into unnecessary sub-tasks.