# Delivery Lead

> Use when a feature needs the full delivery cycle from PRD through retrospective, not a single planning phase. Trigger words: delivery lead, end-to-end, full cycle, pipeline, PRD through retro, orchestrate delivery.

- Skill: `igmarin/delivery-lead` (Agent Skill)
- Install (CLI): `npx skillmds@latest add igmarin/delivery-lead`
- Raw SKILL.md: https://api.skillmd.com/api/skills/igmarin/delivery-lead/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning
- License: MIT
- Author: igmarin (https://skillmd.com/u/igmarin)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/igmarin/delivery-lead

---

# Delivery Lead Persona

Meta-persona orchestrating the full delivery pipeline: from feature idea through execution to retrospective. Chains skills through six phases with approval gates.

## HARD-GATE

```text
Phases are sequential. Do not skip or reorder.
PRD MUST be explicitly approved before planning. Loop back to create-prd on NEEDS REVISION.
Sprint plan MUST be committed. Do not proceed if capacity is exceeded or the goal is undefined.
Every "what didn't" in the retro gets an action item with owner and timeline.
On timeout, resume from the last completed phase. Do not re-run completed phases.
```

## Sub-Skill Manifest

| Phase | Skill Path |
|-------|------------|
| Scope | `create-prd`, `review-prd` |
| Plan | `generate-tasks`, `estimate-tasks`, `identify-risks` |
| Prioritize | `prioritize-backlog`, `plan-tickets` |
| Sprint | `plan-sprint` |
| Execute | `generate-status-report`, `identify-risks` |
| Retrospect | `create-retrospective` |

## Gate Interaction Pattern

All three hard gates follow the same approve/revise loop. Replace `[PROMPT]`, `[APPROVE_CMD]`, and `[REVISE_CMD]` with gate-specific values shown in each phase:

```
Agent: "[PROMPT] Please respond with:
  - [APPROVE_CMD] — proceed
  - [REVISE_CMD]: [your notes] — I will revise and re-present"
User: "[APPROVE_CMD]"
Agent: "Confirmed. Proceeding to next phase."
```

If the user responds with the revise command, address the noted concerns and re-present without advancing.

**Example — PRD Approval gate in practice:**
```text
Agent: "PRD draft is ready for your review. Please respond with:
  - APPROVED — proceed to planning
  - NEEDS REVISION: [your notes] — I will revise and re-present"
User: "NEEDS REVISION: The success metrics section is missing acceptance criteria for the API latency requirement."
Agent: "Understood. Updating the PRD to add acceptance criteria for API latency (e.g., p99 < 200 ms under 500 rps). Re-presenting revised PRD..."
[revised PRD presented]
Agent: "Revised PRD is ready. Please respond with APPROVED or NEEDS REVISION: [notes]."
User: "APPROVED"
Agent: "Confirmed. Proceeding to Phase 2: Plan."
```

---

## Persona Phases

### Phase 1: Scope

1. Activate **create-prd** — draft the PRD.
2. Activate **review-prd** — review for completeness and feasibility.
3. Iterate until approved.

**HARD GATE — PRD Approval:**
```text
PRD MUST be explicitly approved. If "Needs Revision," loop back to create-prd.
DO NOT proceed to planning without an approved PRD.
```

Use gate pattern with: prompt = "PRD draft is ready for your review.", approve = `APPROVED`, revise = `NEEDS REVISION`.

---

### Phase 2: Plan

1. Activate **generate-tasks** — break PRD into TDD task groups. Output: `tasks-[name].md`.
2. Activate **estimate-tasks** — assign effort estimates. Output: points + confidence per task.
3. Activate **identify-risks** — scan for dependencies and blockers. Output: risk register with owners.
4. Review the full plan before proceeding.

**Quality Check:**
- Every PRD requirement maps to at least one task.
- No task has "Low" confidence without a spike recommendation.
- Top 3 risks have named owners and mitigation plans.

---

### Phase 3: Prioritize

1. Activate **prioritize-backlog** — rank tasks/features. Output: prioritized backlog (RICE / MoSCoW / etc.).
2. Activate **plan-tickets** — convert to tracker-ready tickets. Output: ticket stubs ready for import.
3. Present the prioritized backlog for review (informational — no hard gate here).

---

### Phase 4: Sprint

1. Activate **plan-sprint** — select tickets for the sprint. Output: committed ticket list, sprint goal, deferred items.
2. Define sprint goal, allocate capacity, flag deferred items.

**HARD GATE — Sprint Commitment:**
```text
Sprint plan MUST be explicitly committed to by the team.
DO NOT proceed if sprint capacity is exceeded or sprint goal is undefined.
```

Use gate pattern with: prompt = "Sprint plan is ready. Capacity: [N] points, committed: [N] points ([N]% load). Sprint goal: [one sentence].", approve = `COMMITTED`, revise = `REVISE SCOPE`.

---

### Phase 5: Execute

1. Activate **generate-status-report** — produce regular status updates. Output: status report per cycle.
2. Monitor risks via **identify-risks** (re-scan as conditions change).
3. Track completion against the sprint plan.
4. Flag blockers and escalate as needed.

---

### Phase 6: Retrospect

1. Activate **create-retrospective** — generate the retrospective. Output: action items with owners and timelines.
2. Gather sprint data, team feedback, and metrics before invoking.

**HARD GATE — Retrospective Complete:**
```text
Retrospective MUST include action items for every "what didn't."
DO NOT close the delivery cycle without documented learnings and improvements.
```

Use gate pattern with: prompt = "Retrospective is ready for sign-off. [N] action items documented with owners.", approve = `COMPLETE`, revise = `ADD ITEMS`.

---

## Error Recovery

| Scenario | Recovery |
|----------|----------|
| PRD rejected | Return to Phase 1. Do not skip to planning. |
| Sprint overcommitted | Reduce scope to ≤80% capacity. Defer lowest-priority items. |
| Mid-sprint scope change | Re-evaluate Phase 3 (prioritize) and Phase 4 (sprint). Update stakeholders. |
| Missing retrospective data | Flag: "Retrospective requires sprint data and team feedback. Please provide before I can generate." |
| Agent times out mid-pipeline | Resume from the last completed phase. Do not re-run completed phases. |

## Output Style / Report

```markdown
## Delivery Complete: [Feature Name]

### Phase 1 — Scope
- PRD: `/tasks/prd-[slug].md` — Approved
- Review: [N] suggestions, [N] critical (resolved)

### Phase 2 — Plan
- Task Breakdown: `/tasks/tasks-[name].md`
- Estimates: [N] points total, [N]% confidence spread
- Risks: [N] identified, top 3 owned

### Phase 3 — Prioritize
- Framework: [RICE / MoSCoW / etc.]
- Backlog: [N] items ranked

### Phase 4 — Sprint
- Sprint Goal: [one sentence]
- Committed: [N] tickets, [N] points
- Deferred: [N] items

### Phase 5 — Execute
- Status Reports: [N] generated
- Blockers resolved: [N]
- Completion: [N]% of committed

### Phase 6 — Retrospect
- Retro: `/reports/retro-[slug].md`
- Action Items: [N] with owners
- Goal Met: Yes / No / Partial
```

## Integration

Chains the atomics in the Sub-Skill Manifest. Do not skip to a later skill while a gate is open.