agentleFS
lukesw55lukesw55/ai-pm-toolkit/skills/pm-phase-develop/SKILL.md

pm-phase-develop

Skill1 starsChanged 42 days agoMITView on GitHub

Lean Double Diamond **Develop phase** skill for PMs. Invoke when the wedge is defined and the team needs to convert it into **context-rich, executable work**: PRD writing, scope slicing, backlog structure, dependency & risk management, cross-functional orchestration, and the **measurement instrumentation** that must be in place before launch. Trigger on "write a PRD", "escreva a spec", "quebre esse épico", "quais dependências?", "tracking plan", "event schema", "instrumentation", "acceptance criteria", "feature flag strategy", "which prototype tier?", "posso abrir o PR eu mesmo?", or when the team is about to code without a measurement plan. Also covers the PM lens on technical fluency for software products. Bridges to `pm-phase-deliver` for post-launch monitoring and A/B interpretation.

The file

We split this skill into the rules it gives an agent

2 rules. About 0 are common, 1 is distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Do NOT use for post-launch analysis or A/B result interpretation (→ pm-phase-deliver).

    line 35
  2. Distinctive:

    Write concise, actionable product requirements: problem, target user, success criteria, scope & non-scope, trade-offs, open questions.

    line 49

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

PM Phase — Develop

Double Diamond Phase 3 of 4. Converts a defined wedge into executable work with explicit scope, acceptance, dependencies, instrumentation, and cross-functional alignment.

Progressive loading

Load this SKILL.md first. For large or specialized tasks, use references/progressive-loading.md to choose the narrowest supporting reference before reading more.

When to use this skill

Invoke when:

  • a wedge or initiative is defined and the team is about to start building
  • a PRD, spec, or user-story set is needed
  • an epic needs to be sliced into learning-rich increments
  • dependencies across teams must be surfaced before they bite the timeline
  • instrumentation must be designed before the code ships (not patched in after)
  • cross-functional work (design + eng + analytics + legal + support) needs a shared plan
  • a technical trade-off needs a PM lens (cost vs value vs reliability vs speed-to-learn)

Do NOT use for post-launch analysis or A/B result interpretation (→ pm-phase-deliver).

Prime directive

Executable work, not requirement novels. Good requirement writing gives engineering and design context and room to solve — it does not over-prescribe, does not omit success criteria, does not let scope drift silently. Instrumentation is designed upfront because shipped code without the right events is shipped blindly.

Calibrated disagreement

The default failure in Develop is speccing requirements, scope, or implementation premises nobody justified. Challenge scope that outruns evidence or capacity before it becomes acceptance criteria — see ../DOCTRINE.md.

Core sub-skills

1. PRD and specification writing

Write concise, actionable product requirements: problem, target user, success criteria, scope & non-scope, trade-offs, open questions.

Outputs: PRD (1–5 pages), linked acceptance criteria, annotated flows, open-questions section, non-requirements.

Anti-patterns: novels, pixel-by-pixel UI dictation without need, omitting success criteria, leaving scope ambiguities unresolved, letting docs drift from reality.

→ Deep-dive: references/prd-writing.md

2. Backlog structuring and scope slicing

Break bets into increments that maximise learning per week. Strong PMs shape the grain size of delivery; the expert move is keeping options open while moving.

Outputs: story map, backlog hierarchy, MVP/MVC definition, staged rollout plan.

At stage 5, pair this sub-skill with the validated One Pager. Compare bets only when several compete for capacity, then produce scope-slices.md with V1, later slices, the learning goal and non-goals before stage-6 PRD work.

Anti-patterns: giant epics, backlog as dumping ground, confusing output granularity with customer value, slicing by component rather than user need.

→ Deep-dive: references/backlog-scope-slicing.md

3. Dependency and risk management

Surface cross-team dependencies, delivery risks, and assumption risks before they become schedule or quality problems. Maintain a RAID log that people actually read.

Outputs: dependency map, risk register, mitigation plan, escalation note, planning review summary.

Anti-patterns: hidden dependencies, no owners, optimism bias, raising blockers late, conflating likelihood with impact.

→ Deep-dive: references/dependency-risk.md

4. Cross-functional delivery orchestration

Coordinate design, engineering, analytics, research, legal, ops, support, and GTM so a product change lands coherently. Product value is realised through orchestration, not PM heroics.

Outputs: integrated plan, role map (RACI-lite), blocker log, stakeholder action list, launch-readiness review.

Anti-patterns: owning the "how" instead of enabling domain owners, reliance on heroics, meetings-as-artefact, escalating without options.

→ Deep-dive: references/cross-functional-orchestration.md

The stage-7 artefact this skill produces is the Tech Team Kickoff — see references/tech-team-kickoff.md for the 90-min agenda template (stage 7 of 8 in ../WORKFLOW.md).

5. Tracking-plan design (pre-launch instrumentation)

Define what events, properties, and metrics must exist before code ships, so post-launch analysis and experiments are trustworthy. Design tracking plans alongside the PRD, not after.

Outputs: tracking plan, event schema, instrumentation spec, metric dictionary entry, implementation QA checklist.

Anti-patterns: event sprawl, inconsistent naming, tracking everything, no taxonomy owner, implementing events without first linking them to outcomes.

→ Deep-dive: references/tracking-plan-design.md

6. Technical fluency (PM lens)

Understand enough of architecture, APIs, data flows, constraints, observability, and feasibility to make sound product trade-offs with engineering — not out-engineer them.

Outputs: technical trade-off memo, API/flow diagram annotations, feasibility notes, non-functional requirement list.

Anti-patterns: cargo-cult jargon, promising incoherent solutions, ignoring NFRs, relying on eng to translate every technical implication into product language.

→ Deep-dive: references/technical-fluency.md

7. Prototyping ladder (stage 6)

Pick where the stage-6 prototype lives by the question it must answer, the risk if it is wrong and the engineering cost tolerated: a throwaway prototype outside the codebase for comprehension and desirability, a code prototype on a disposable branch of the real codebase (built with a coding agent, never merged as-is) for interaction and integration fidelity, or a small PM-authored change shipped as a reviewed pull request for copy, configuration, flags and minor UI. Never core logic, data model, billing, auth, permissions or migrations: the PM does not ship code inferior to the team's next to the team's.

Outputs: prototype decision record, sandbox repo request, validated-prototype evidence with participants and locators for the stage-6 gate.

Anti-patterns: demo mistaken for feasibility, merging the prototype branch, PM as junior engineer, a shipped change without a flag or rollback, polishing before the risk is resolved.

→ Deep-dive: references/prototyping-ladder.md

Workflow

  1. Load context when relevant — for project work, read .ai/memory/active-context.md first when present and resolve <slug> before opening relevant project files: PRD/spec, priorities, and tracking plan. If no pointer exists, do not infer a project; bootstrap only when durable project context is needed and the name is known. When present, .ai/memory/org/personas.md names the archetype the PRD serves.
  2. Classify the ask — PRD, slicing, dependency/risk, orchestration, instrumentation, or tech fluency?
  3. Anchor on the wedge — restate the problem + success criteria + non-goals from Define. If missing, loop back.
  4. Draft the smallest useful artefact — PRD that fits on ~3 pages, not 20; tracking plan that tracks the 5 events that matter, not 50.
  5. Name dependencies and risks explicitly — each with owner and mitigation.
  6. Persist durable outputs — when this task creates or materially changes project context, save the PRD, dependencies, tracking plan, or prototype decision under .ai/memory/projects/<slug>/ in the relevant files. Read-only or transient work needs no memory entry.

Output contract

## [Artefact type] — [short title]

### Wedge recap
### Target user + success criteria
### Scope IN / OUT
### Acceptance criteria or event schema
### Dependencies + owners
### Risks + mitigations
### Open questions
### Files/tickets to produce downstream

Integration

  • Upstream: pm-phase-define (priorities, KPIs, strategy).
  • Downstream: pm-phase-deliver (post-launch monitoring uses tracking plan).
  • Transversais: pm-transversal-docs (PRD in Confluence, tickets in Jira), pm-transversal-stakeholder (getting sign-off).
  • Cross-functional pairings: your engineering architecture partner for architecture trade-offs; your QA lead for acceptance-criteria stress-test; a code reviewer once a PR exists; your designer for UI scope.
  • Archetype lenses (load when the product type warrants): pm-archetype-ai for probabilistic features, pm-archetype-enterprise for B2B / governance, pm-archetype-growth for funnel-shaped work, pm-archetype-platform for API/SDK/infra.

Communication modes follow ../../docs/patterns/COMMUNICATION_MODES.md. Per-skill: Lean (default) is the 1-page PRD + tracking plan + dependency list; Standard is the full PRD with open questions; Caveman is ticket-sized — problem, slice, metric, deps, risk.

Success criteria

  • engineering and design start without re-asking "what are we building and why?"
  • scope changes are visible and costed, not silent
  • post-launch analysis is possible because instrumentation was right the first time
  • cross-functional partners know their slice + handoff by the time coding starts
  • dependency surprises drop quarter over quarter

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.