oma-pm · first-fluke, oma — Claude Code skill for product planning
oma-pm is a Claude Code skill that turns product requirements into a prioritized task plan with dependencies and acceptance criteria. It prepares the plan before work is handed to specialist agents.
MIT ★ 1,472 updated 2026-10-29
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agentWhat oma-pm does
oma-pm takes a product goal, constraints, and project context, then breaks the work into tasks. Each task gets an agent assignment, priority, dependencies, and acceptance criteria. When relevant, the plan also includes API contracts or data model sketches. It produces JSON alongside a breakdown compatible with task-board.md.
The skill checks task boundaries, sequencing, and opportunities for parallel work; security and testing belong in each task. It saves the results to .agents/results/plan-{sessionId}.json and .agents/results/current-plan.md. Ambiguous requirements trigger clarification before breakdown, while an overly broad scope is split into phases. This is a planning tool, not a code implementer; implementation goes to specialist agents.
What it helps with
- Break requirements into testable tasks
- Set task priorities and dependencies
- Draft API contracts before implementation
- Create acceptance criteria for planned work
Example prompts for the agent
- Break these feature requirements into tasks with priorities and acceptance criteria.
- Draft an implementation plan with dependencies and API contracts.
- Plan this work using ISO 21500 concepts and consider risks through ISO 31000.
How to install oma-pm
1Plugin marketplace
/plugin marketplace add first-fluke/oh-my-agent/plugin install oma@oh-my-agentThis installs the whole oma plugin with all its skills
2Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a claude-code3Manually: put the files in place
~/.claude/skills/oma-pm/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/oma-pm/
1Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a codex2Manually: put the files in place
.agents/skills/oma-pm/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a cursor2Manually: put the files in place
.cursor/skills/oma-pm/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install first-fluke/oh-my-agent benchmarks/runs/oma/.agents/skills/oma-pm2Manually: put the files in place
.github/skills/oma-pm/SKILL.md1Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a gemini-cli2Platform CLI
gemini skills install https://github.com/first-fluke/oh-my-agent --path benchmarks/runs/oma/.agents/skills/oma-pmManually: put the files in place
.devin/skills/oma-pm/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about oma-pm
How do I install oma-pm in Claude Code?
Run /plugin marketplace add first-fluke/oh-my-agent, then /plugin install oma@oh-my-agent.
What does oma-pm do?
It turns product requirements into a structured plan with assigned agents, priorities, dependencies, and acceptance criteria. It can also draft API contracts and data models.
Does oma-pm implement code?
No. It produces planning artifacts for downstream execution; coding is delegated to specialist agents, with testing and security expectations included in tasks.
Source text
SKILL.md · MIT
---
name: oma-pm
description: Product manager that decomposes requirements into actionable tasks with priorities and dependencies. Use for planning, requirements, specification, scope, prioritization, task breakdown, and ISO 21500, ISO 31000, or ISO 38500-aligned planning recommendations.
---
# PM Agent - Product Manager
## Scheduling
### Goal
Turn ambiguous or complex product requests into actionable, dependency-aware plans with clear tasks, priorities, acceptance criteria, API contracts, and risk/governance notes.
### Intent signature
- User asks for planning, requirements, specification, scope, prioritization, task breakdown, roadmap, or implementation plan.
- User needs work decomposed for specialist agents or orchestrator execution.
### 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
### Expected inputs
- User request, product goal, constraints, target users, and acceptance expectations
- Existing codebase context, architecture constraints, and integration points
- Optional standards, risk, governance, or orchestration requirements
### Expected outputs
- JSON plan and `task-board.md`-compatible task breakdown
- Agent assignment, title, priority, dependencies, acceptance criteria, security/testing expectations
- API contracts or data model sketches when relevant
- Saved plan artifacts under `.agents/results/`
### Dependencies
- `resources/execution-protocol.md`, examples, task template, and ISO planning guide
- Shared API contract references and project context-loading rules
- Downstream specialist skills for implementation
### Control-flow features
- Branches by ambiguity, dependency structure, risk level, and whether standards/governance framing is needed
- Produces planning artifacts rather than code
- Optimizes for parallelizable specialist-agent execution
## Structural Flow
### Entry
1. Clarify the product goal, constraints, and target deliverables.
2. Identify technical domains and required contracts.
3. Decide whether ISO/risk/governance framing is relevant.
### Scenes
1. **PREPARE**: Gather requirements, constraints, and context.
2. **REASON**: Decompose work, identify dependencies, risks, and API/data contracts.
3. **ACT**: Produce JSON plan and task-board-compatible output.
4. **VERIFY**: Check task atomicity, acceptance criteria, security/testing coverage, and dependency shape.
5. **FINALIZE**: Save plan artifacts and summarize execution path.
### Transitions
- If requirements are ambiguous, clarify before decomposition.
- If tasks are tightly coupled, refine contracts or sequencing.
- If architecture is uncertain, coordinate with architecture before implementation planning.
- If the user needs automated execution, hand off to orchestrator after plan approval.
### Failure and recovery
- If scope is too broad, split into phases.
- If acceptance criteria are vague, rewrite them into testable outcomes.
- If dependencies block parallel execution, surface sequencing explicitly.
### Exit
- Success: plan is actionable, testable, prioritized, and compatible with orchestrator execution.
- Partial success: unresolved assumptions or dependencies are explicit.
## Logical Operations
### Actions
| Action | SSL primitive | Evidence |
|--------|---------------|----------|
| Read requirements/context | `READ` | User request and project context |
| Select planning structure | `SELECT` | Task template and workflow needs |
| Infer tasks and dependencies | `INFER` | Domain decomposition |
| Validate acceptance criteria | `VALIDATE` | Checklist and task schema |
| Write plan artifacts | `WRITE` | JSON plan and task-board markdown |
| Notify plan summary | `NOTIFY` | Final planning report |
### Tools and instruments
- Task template, examples, ISO planning guide, shared API contracts
- Local filesystem for result artifacts
### Canonical workflow path
```text
1. Define API/data contracts.
2. Decompose tasks with agent, title, priority, dependencies, and acceptance criteria.
3. Save `.agents/results/plan-{sessionId}.json` and `.agents/results/current-plan.md`.
```
### Resource scope
| Scope | Resource target |
|-------|-----------------|
| `MEMORY` | Requirements, assumptions, dependencies |
| `LOCAL_FS` | `.agents/results/plan-{sessionId}.json`, `.agents/results/current-plan.md` |
| `CODEBASE` | Optional project context and API/data model references |
### Preconditions
- Product goal and planning boundary are sufficiently clear.
- Required implementation domains can be identified.
### Effects and side effects
- Creates plan artifacts and task boards.
- Influences downstream agent assignments and execution order.
- Does not directly implement code.
### Guardrails
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
7. When relevant, structure plans using ISO 21500 concepts, risk prioritization using ISO 31000 thinking, and responsibility/governance suggestions inspired by ISO 38500
### 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
## References
Follow `resources/execution-protocol.md` step by step.
See `resources/examples.md` for input/output examples.
Use `resources/iso-planning.md` when the user needs standards-based planning, risk framing, or governance-oriented recommendations.
Save plan to `.agents/results/plan-{sessionId}.json` and `.agents/results/current-plan.md`.
Vendor-specific execution protocols are injected automatically by `oma agent:spawn`.
Source files live under `../_shared/runtime/execution-protocols/{vendor}.md`.
- Execution steps: `resources/execution-protocol.md`
- Plan examples: `resources/examples.md`
- ISO planning guide: `resources/iso-planning.md`
- Error recovery: `resources/error-playbook.md`
- Task schema: `resources/task-template.json`
- API contracts: `../_shared/core/api-contracts/`
- Context loading: `../_shared/core/context-loading.md`
- Reasoning templates: `../_shared/core/reasoning-templates.md`
- Clarification: `../_shared/core/clarification-protocol.md`
- Context budget: `../_shared/core/context-budget.md`
- Lessons learned: `../_shared/core/lessons-learned.md`
© First Fluke · MIT · first-fluke/oh-my-agent
Similar skills
All skills for Agent setup: memory, context, orchestration →oma-pm by other authors comes first.