Skip to main content
skill CX Codex

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

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent
Open on GitHub

What 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-agent

This 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-code

3Manually: put the files in place

~/.claude/skills/oma-pm/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/oma-pm/

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.

oma-pm First Fluke oma-pm — a skill for Claude Code and Codex decomposes product requirements into scoped tasks with dependencies and acceptance criteria. Generates plan artifacts for specialist agents and orchestrators. CX Codex +1 ★ 1,472repo stars bmad-forge-idea bmad-code-org bmad-forge-idea is a Claude Code skill that probes an early idea through questions and competing perspectives. Invoke it to challenge assumptions, find weak spots, or clarify a plan. CX Codex +1 17,000installs scope jsmastery-pro The skill adds a /scope command that turns a product idea into a phased feature plan in docs/scope/, then reconciles that plan with what actually shipped. CX Codex +1 5,100installs plan-writing davila7 plan-writing breaks work into short tasks, each with its own verification step. Useful for feature work, refactoring, or any multi-step job. CX Codex +1 188installs planning-and-task-breakdown addyosmani planning-and-task-breakdown breaks specifications into small, testable tasks with clear acceptance criteria. Prevents agents from jumping straight into coding before dependencies and risks are mapped. CX Codex +1 80,700installs before-you-build OneWave-AI The before-you-build skill identifies the main risk in an idea and suggests a small test before implementation starts. Use it to assess a product, feature, MVP, agent, or automation. CX Codex +1 130installs project-to-linear davila7 project-to-linear breaks project into epics and tasks, creates Linear hierarchy with dependencies and labels. CX Codex +1 177installs

From the same set69

The whole set →
oma-mobile oma-mobile — a mobile-focused skill: it builds screens and widgets in Flutter or React Native, wires camera, GPS, push and offline handling, then runs the checks. CX Codex +1 ★ 1,472repo stars oma-debug oma-debug — a skill for Claude Code and Codex isolates bugs, writes targeted fixes, and creates regression tests. Runs when tests fail, services crash, or code suffers from race conditions. CX Codex +1 ★ 1,472repo stars oma-qa The oma-qa skill for Claude Code and Codex reviews changes for security, performance, accessibility, and correctness. It checks a diff, runs relevant tools, and reports reproducible findings with fixes. CX Codex +1 ★ 1,472repo stars oma-search oma-search — a skill for Claude Code and Codex that routes queries across external documentation, web search, and remote code. It picks the matching retrieval channel and returns answers backed by citations. CX Codex +1 ★ 1,472repo stars oma-brainstorm oma-brainstorm — a skill for exploring intent, constraints, and alternative approaches before planning or coding. Use it when you have an idea but the path forward is unclear. CX Codex +1 ★ 1,472repo stars oma-pm oma-pm — a skill for Claude Code and Codex decomposes product requirements into scoped tasks with dependencies and acceptance criteria. Generates plan artifacts for specialist agents and orchestrators. CX Codex +1 ★ 1,472repo stars oma-design oma-design resolves a project's design direction and maintains DESIGN.md as the visual contract. Picks an external design skill — Interface Design, Taste, or Impeccable — for the task at hand. CX Codex +1 ★ 1,472repo stars oma-hwp oma-hwp converts Korean HWP, HWPX, and HWPML documents into Markdown or JSON for LLM prompts and retrieval pipelines. CX Codex +1 ★ 1,472repo stars

Project sponsors

Companies that keep this analytics open