product-manager

Decompose large features into DAG-structured phases with a YAML manifest.

31|6|Updated Dec 13, 2025
One-click install
npx skills add https://github.com/MatiasComercio/agentic-config --skill product-manager-matiascomercio
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: product-manager
Source: https://github.com/MatiasComercio/agentic-config/tree/main/core/skills/product-manager
Command: npx skills add https://github.com/MatiasComercio/agentic-config --skill product-manager-matiascomercio

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps product teams translate vague feature ideas into a concrete, executable plan by decomposing them into self-contained phases with clear inputs, outputs, and dependencies, all driven by a DAG.

Core Features & Use Cases

  • Phase decomposition: Break large features or fixes into self-contained, testable phases that can be implemented independently.
  • DAG dependencies: Represent phase relationships with a directed acyclic graph to enable parallel work where possible.
  • Output manifest: Produce a YAML manifest that details phases, acceptance criteria, and artifacts.

Quick Start

Provide a feature prompt, for example: "Add multi-item checkout with discount codes." The skill will generate a DAG of phases with explicit inputs, outputs, and acceptance criteria, and output a YAML manifest.

Frequently Asked Questions about product-manager

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I break down a large feature into deployable phases?

Feature decomposition organizes large features into self-contained phases with explicit inputs, outputs, and dependencies. This Skill applies a DAG structure to generate a YAML manifest that defines phase boundaries, acceptance criteria, and testable work items, enabling parallel development where dependencies allow.

What is a DAG and why use it for feature planning?

A directed acyclic graph (DAG) represents phase relationships and dependencies without circular loops. DAG-structured planning identifies which phases can run in parallel and which must sequence, reducing bottlenecks and clarifying critical path dependencies in feature delivery.

How do I use this to plan a feature like multi-item checkout with discounts?

Provide a feature prompt describing what you need built. The Skill generates a DAG of phases with explicit inputs, outputs, and acceptance criteria, then outputs a YAML manifest detailing phase boundaries, hard and soft dependencies, and concrete deliverables for each phase.

What output format does the manifest use?

The Skill produces a YAML manifest that structures phases with inputs, outputs, acceptance criteria, and traceable work items. This format captures phase-level deliverables and dependency relationships, making the plan executable and testable by development teams.

Can phases be implemented independently, or must they follow a strict sequence?

Phases are self-contained and testable. The DAG defines both hard dependencies (strict sequencing required) and soft dependencies (preferred but not blocking), so teams can identify which phases run in parallel and which must wait, optimizing delivery timeline.