staged-delivery-workflow

Structures multi-file implementation tasks into phased stages with validation.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/piotrgawel5/project_delta --skill staged-delivery-workflow
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: staged-delivery-workflow
Source: https://github.com/piotrgawel5/project_delta/tree/main/.claude/skills/staged-delivery-workflow
Command: npx skills add https://github.com/piotrgawel5/project_delta --skill staged-delivery-workflow

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill enforces a phased, validated approach to complex implementation tasks that span multiple files or layers, preventing scope creep and unsafe architectural guesses by requiring a clear pre-flight, stage-by-stage progression and using context.md as the single source of truth.

Core Features & Use Cases

  • Phase-based workflow (P0–P5): Define and enforce strict stage boundaries (P0 foundations through P3 quality hardening, with optional P4/P5 for hardening and rollout).
  • Pre-flight and blocker detection: Mandatory context.md review, declared files-per-stage, and explicit ambiguity surfacing before any code is written.
  • Validation gates: Require repository validations at each stage (typecheck, lint, tests) and provide failure protocols and invariant checklists.
  • Scope guard and documentation rules: Explicit rules for when to update context.md and how to list residual risks, preventing silent scope expansion.
  • Use Cases: Implementing a backend+UI feature that touches multiple packages, coordinating migrations with UI changes, and writing integration tests plus documentation updates.

Quick Start

Use staged-delivery-workflow to break a multi-file feature into P0–P3, declare files per stage, and validate each stage with npm run typecheck && npm run lint && npm run test.

Frequently Asked Questions about staged-delivery-workflow

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

FAQPage Schema
How do I break down a multi-file feature into phased development stages?

Phased development structures complex multi-file implementation tasks into P0–P5 stages, enforcing scoped changes and mandatory validation after each stage. You declare specific files per stage and use context.md as the single source of truth.

When do I need a staged delivery workflow for cross-file features?

A staged delivery workflow is needed for cross-file features touching more than two files, backend plus UI work, integration tests, and coordinated commit documentation. It prevents scope creep and unsafe architectural guesses.

How do I enforce validation gates between implementation stages?

Validation gates enforce repository checks at each stage by requiring commands like npm run typecheck, npm run lint, and npm run test to pass. The workflow provides failure protocols and invariant checklists before progressing to the next phase.

Can I use staged delivery for coordinating database migrations with UI changes?

Yes, staged delivery supports coordinating migrations with UI changes by requiring you to declare files per stage and validate each phase independently. This ensures backend and UI updates are committed together safely.

How do I surface ambiguity and blockers before writing code in phased development?

Phased development surfaces ambiguity through mandatory pre-flight blocker detection, requiring a context.md review and explicit ambiguity documentation before any code is written. This prevents silent scope expansion.

What are the limitations of using context.md as a single source of truth for multi-file changes?

The limitation is that context.md must be actively updated when scope changes occur, requiring explicit documentation rules to list residual risks. Without this maintenance, it cannot effectively prevent scope creep or unsafe architectural guesses.