Oma Pm Agent Skill
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.
Install
one command, takes just this skill from the repositorynpx skills add https://github.com/first-fluke/oh-my-agent --skill oma-pmThe instruction itself
26 sections, as written by the authorPM 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
- Clarify the product goal, constraints, and target deliverables.
- Identify technical domains and required contracts.
- Decide whether ISO/risk/governance framing is relevant.
Scenes
- PREPARE: Gather requirements, constraints, and context.
- REASON: Decompose work, identify dependencies, risks, and API/data contracts.
- ACT: Produce JSON plan and task-board-compatible output.
- VERIFY: Check task atomicity, acceptance criteria, security/testing coverage, and dependency shape.
- 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
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
- API-first design: define contracts before implementation tasks
- Every task has: agent, title, acceptance criteria, priority, dependencies
- Minimize dependencies for maximum parallel execution
- Security and testing are part of every task (not separate phases)
- Tasks should be completable by a single agent
- Output JSON plan + task-board.md for orchestrator compatibility
- 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
Other skills for the same job
different authors, same section of the catalogue
Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.
Intelligently organizes your files and folders across your computer by understanding context, finding duplicates, suggesting better structures, and automating cleanup tasks. Reduces cognitive load and keeps your digital workspace tidy without manual effort.
Generates creative domain name ideas for your project and checks availability across multiple TLDs (.com, .io, .dev, .ai, etc.). Saves hours of brainstorming and manual checking.
You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
Implements Manus-style file-based planning for complex tasks. Creates task_plan.md, findings.md, and progress.md. Use when starting complex multi-step tasks, research projects, or any task requiring >5 tool calls.
Creative research ideation and exploration. Use for open-ended brainstorming sessions, exploring interdisciplinary connections, challenging assumptions, or identifying research gaps. Best for early-stage research planning when you do not have specific observations yet. For formulating testable hypotheses from data use hypothesis-generation.
Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning
Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
How to use it
Take first-fluke/oh-my-agent-oma-pm from the repository into ~/.claude/skills for personal
use, or into .claude/skills inside a project.
The agent identifies a skill by the name field in its header. Two skills with the
same name cannot sit side by side — one of them will be ignored.