oma-pm · first-fluke, frontend — скилл для Claude Code: что делает и как установить
Скилл oma-pm для Claude Code и Codex декомпозирует требования к продукту в дерево задач с зависимостями и критериями приёмки. Готовит артефакты планирования для субагентов и оркестратора.
MIT ★ 1 472 обновлён 2026-11-12
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma-frontend@oh-my-agentЧто делает oma-pm
Скилл превращает общие продуктовые запросы в структурированные планы: выделяет приоритеты, формирует контракты API, описывает модели данных и распределяет роли между субагентами. Каждая задача получает уровень изоляции, контекст проверок и требования к тестированию.
Результат работы сохраняется в локальную файловую систему. Скилл формирует JSON-план по пути .agents/results/plan-{sessionId}.json и разметку задач для трекера task-board.md. Логика опирается на принципы планирования ISO 21500 и оценку рисков ISO 31000.
Скилл создаёт только артефакты планирования и намеренно не пишет исполняемый код. Задачи проектируются так, чтобы минимизировать связность и запустить параллельную работу профильных агентов.
Какие задачи решает
- разбить сложные продуктовые фичи на изолированные задачи для агентов
- составить схему зависимостей и приоритеты выполнения спринта
- описать контракты API и критерии приёмки до написания кода
- сохранить JSON-план в
.agents/results/для оркестратора
Примеры запросов агенту
- Спланируй интеграцию OAuth и разбей её на задачи с зависимостями для агентов
- Составь план спринта с контрактами API и критериями приёмки для рефакторинга биллинга
- Сформируй JSON-план и task-board.md для автоматического запуска оркестратора
Как установить oma-pm
1Через маркетплейс плагинов
/plugin marketplace add first-fluke/oh-my-agent/plugin install oma-frontend@oh-my-agentКоманда ставит плагин oma-frontend целиком, со всеми его скиллами
2Через Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a claude-code3Вручную: положить файлы
~/.claude/skills/oma-pm/SKILL.mdПапка скилла целиком; для одного проекта — .claude/skills/oma-pm/
1Через Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a codex2Вручную: положить файлы
.agents/skills/oma-pm/SKILL.mdДля всех проектов — ~/.agents/skills/
1Через Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a cursor2Вручную: положить файлы
.cursor/skills/oma-pm/SKILL.mdCursor читает и .agents/skills/, и .claude/skills/
1GitHub CLI
gh skill install first-fluke/oh-my-agent .claude-plugin/domains/frontend/skills/oma-pm2Вручную: положить файлы
.github/skills/oma-pm/SKILL.md1Через Skills CLI (Vercel)
npx skills add first-fluke/oh-my-agent --skill oma-pm -a gemini-cli2Командой платформы
gemini skills install https://github.com/first-fluke/oh-my-agent --path .claude-plugin/domains/frontend/skills/oma-pmВручную: положить файлы
.devin/skills/oma-pm/SKILL.mdСтарый путь .windsurf/skills/ тоже читается
Claude.ai
Упакуйте папку в zip и загрузите в Settings → Capabilities → Skills
По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов
Вопросы об oma-pm
Как установить oma-pm в Claude Code?
Выполните команду npx skills add first-fluke/oh-my-agent --skill oma-pm -a claude-code. Файл навыка сохранится в ~/.claude/skills/oma-pm/SKILL.md.
Пишет ли oma-pm код в проекте?
Нет. Скилл готовит спецификации, интерфейсы и JSON-планы задач, а непосредственное написание кода делегирует профильным субагентам.
Куда сохраняются результаты работы?
План записывается в файл .agents/results/plan-{sessionId}.json и дублируется в формате markdown для доски task-board.md.
Исходный текст
SKILL.md · MIT
---
name: oma-pm
description: Turn product requirements into scoped tasks with dependencies and
acceptance criteria. Use for implementation planning and prioritization.
---
# 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/`
```yaml
outputs:
- name: plan
description: PM task breakdown JSON for orchestrator consumption
artifact: ".agents/results/plan-*.json"
required: true
```
### 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` using the injected session ID. Write the run-scoped report from the shared memory/result contract.
```
### Resource scope
| Scope | Resource target |
|-------|-----------------|
| `MEMORY` | Requirements, assumptions, dependencies |
| `LOCAL_FS` | `.agents/results/plan-{sessionId}.json`, injected claim path and task/run-scoped report |
| `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. For changed interfaces, reuse or define API/data contracts before dependent implementation tasks
2. Every executable task has: agent, title, `{id, description}` acceptance criteria, covering `required_checks` with exact argv/cwd, a replayable `task` prompt, priority tier (1 = independent, lower runs first), dependencies, and scope
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
- Local code tools: `../_shared/core/code-intelligence.md` (code search/navigation)
- Runtime identity and run-scoped reports: `../_shared/runtime/memory-protocol.md`, `../_shared/runtime/result-contract.md`
- Execution steps (follow for the selected task): `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`
- Ultrawork PLAN phase protocol: `resources/plan-phase-protocol.md` (used when this skill runs inside the ultrawork workflow)
- Task board spec (orchestrator-consumed format): `../oma-orchestration/resources/memory-schema.md`
- Human-readable tracker: when running inside the `/plan` workflow, also generate `docs/plans/work/{NNN}-{name}.md` per `.agents/workflows/plan.md`
- API contract template (SSOT): `../_shared/core/api-contracts/template.md`; write generated contracts to `.agents/results/api-contracts/` (run artifact) or `docs/plans/contracts/` (durable spec)
- Context loading: `../_shared/core/context-loading.md`
- Planning depth: `../_shared/core/difficulty-guide.md` (unresolved scope or dependencies)
- Clarification: `../_shared/core/clarification-protocol.md`
- Context budget: `../_shared/core/context-budget.md`
- Lessons learned: `../_shared/core/lessons-learned.md` (matching prior failure or requested retrospective)
© First Fluke · MIT · first-fluke/oh-my-agent
Похожие скиллы
Все скиллы по теме «Настройка агента: память, контекст, субагенты» →Сначала — oma-pm от других авторов.