Menu
Module: Agent-Led Project Planning, Scoping, and Execution Structuring
The review-first prompt is selected by default. You can switch to a direct command or download a local copy.
Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/lebiraja/skills4agents --skill agent-module-project-planning-and-scopingThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Showing SKILL.md
Based on SOC occupation classification
| name | agent-module-project-planning-and-scoping |
| description | Module: Agent-Led Project Planning, Scoping, and Execution Structuring |
agent.module.project-planning-scoping1.0.0productionUse this module when an agent is tasked with planning any project, whether it's a new feature, full-stack system, refactor, migration, or incident response.
Apply when:
Do not apply directly when:
Pattern: Collaborative Discovery → Risk-Aware Execution Planning → Monitored Checkpoint Delivery
Core design rules:
Three-Stage Planning Flow:
Stage 1: Collaborative Discovery (Human + Agent)
├─ Problem Definition
├─ Constraints & Trade-offs
└─ Scope Boundary
↓
Stage 2: Execution Planning (Agent-Driven)
├─ Risk Inventory & Ranking
├─ Dependency Graph Analysis
└─ Skill-Module Phase Organization
↓
Stage 3: Execution with Checkpoints (Agent-Monitored)
├─ Phase Execution (with monitoring)
├─ Exit Criteria Validation
├─ Risk Escalation (if new risks emerge)
└─ Checkpoint Review & Rollback Plan
Sub-phase A1: Problem Definition
Exit criteria:
Sub-phase A2: Constraints & Trade-offs
Exit criteria:
Sub-phase A3: Scope Boundary
Exit criteria:
Deliverable: Discovery Document
# Project Discovery: [Project Name]
## Problem Definition
[One paragraph problem statement]
**Primary Stakeholders:**
- [Name/Role]: [Goal/Need]
**Success Metrics:**
- [Metric 1]: [Target]
- [Metric 2]: [Target]
## Constraints & Trade-offs
| Constraint | Value | Impact |
|---|---|---|
| Timeline | [Date] | [What gets cut if slipped] |
| Budget | [Amount] | [Scope implications] |
| Team | [Size/Availability] | [Parallelization limits] |
**Trade-off Priority:** [If forced to choose, we prioritize...]
## Scope Boundary
**In-Scope:** [Feature 1, Feature 2, Feature 3]
**Out-of-Scope:** [Feature A, Feature B, Feature C]
**Assumptions:** [What could change this boundary?]
Sub-phase B1: Risk Inventory & Ranking
Exit criteria:
Sub-phase B2: Dependency Graph Analysis
Exit criteria:
Sub-phase B3: Skill-Module Phase Organization
Example structure:
Phase 1 (De-Risk & Foundation)
├─ Spike: Architecture + tech decisions
├─ Skill: Input Validation Standard (define contracts)
└─ Exit: API contracts are locked, team aligned on tech stack
Phase 2 (Core Backend)
├─ Skill: Django + PostgreSQL Standard
├─ Skill: Error Taxonomy & Handling
└─ Exit: Core API endpoints tested, error handling consistent
Phase 3 (Frontend & BFF)
├─ Skill: Frontend UI (Shadcn + Magic UI)
├─ Skill: Full-Stack AI Platform (if AI involved)
└─ Exit: UI implemented, BFF routes authenticated
Phase 4 (Observability & Hardening)
├─ Skill: Observability & Instrumentation
├─ Skill: Testing Strategy & Coverage
└─ Exit: Logging/metrics in place, test coverage > 80%
Phase 5 (Launch Readiness)
├─ Deploy to staging
├─ Run validation suite
├─ Execute runbooks
└─ Exit: Production-ready, rollback plan in place
Exit criteria:
Deliverable: Execution Plan
# Execution Plan: [Project Name]
## Risk Inventory (Ranked by Impact × Likelihood)
| Risk | Likelihood | Impact | Mitigation |
|---|---|---|---|
| [Risk 1] | High | High | [Spike, proto, expert review] |
## Dependency Graph
[ASCII or narrative: what depends on what]
## Critical Path
[Longest chain; this determines project duration]
## Execution Phases
### Phase 1: [Name]
**Skills Applied:** [Module 1, Module 2]
**Dependencies:** [What must be done first]
**Deliverables:** [Concrete outputs]
**Exit Criteria:** [Definition of done for this phase]
**Rollback Plan:** [If this phase fails, what do we do?]
[Repeat for each phase]
## Checkpoint Gates
- **After Phase 1:** Risk review + stakeholder alignment
- **After Phase 2:** Architecture validation + security audit
- **[etc.]**
During execution, agent monitors:
At each phase boundary:
Exit criteria:
| Decision Area | Preferred Option | Alternative | Selection Rule |
|---|---|---|---|
| Planning depth | Collaborative (both voices) | Agent-only or human-only | Both perspectives prevent blind spots and build buy-in. |
| Risk ranking method | Impact × Likelihood matrix | Gut feel / intuition | Matrix is repeatable and helps prioritize mitigation. |
| Work decomposition | Skill-module aligned + dependency ordering | Linear sequential phases | Skill alignment reuses existing guidance; dependency ordering enables parallelization. |
| Execution monitoring | Checkpoint gates after each phase | Continuous free-form | Gates create decision moments; prevent silent scope creep. |
| Scope change process | Explicit re-plan (risk/timeline impact) | Ad-hoc "just add it" | Explicit process clarifies trade-offs and prevents chaos. |
| Metric | Target | Rationale |
|---|---|---|
| Discovery completion | < 1 week for most projects | Prevents analysis paralysis; lock strategy early |
| Planning completion | < 3 days after discovery | Execution plan should be ready before first line of code |
| Phase duration | 1–2 weeks per phase (typical) | Longer phases are risky; shorter checkpoints catch issues faster |
| Risk escalation time | < 24 hours of discovery | New risks should surface quickly; silent problems are worst |
| Scope change decision time | < 48 hours of request | Delays create chaos; explicit yes/no/defer is better than indecision |
| Phase success rate | >= 90% phases meet exit criteria on first attempt | If lower, planning accuracy is poor; re-examine up-front work |
| Rollback execution time | <= 4 hours per phase | Rollback should be faster than continuing with broken work |
| Risk | Likelihood | Impact | Control |
|---|---|---|---|
| Analysis paralysis (discovery too long) | High | Medium | Set hard deadline for discovery (1 week max); use discovery doc template to keep focused |
| Scope creep (new features sneak in mid-project) | High | High | Explicit scope boundary in Phase A; checkpoint gates that require scope-change triage; escalate immediately |
| Hidden dependencies (phases blocked on undiscovered work) | Medium | High | Dependency graph must be explicit; agent asks "what could block this" for each phase |
| Risk blindness (risks not identified upfront) | Medium | High | Risk inventory should have 5–10 items; if fewer, agent probes deeper; escalate if major risk appears mid-project |
| Timeline slip (constant pushing of deadlines) | High | Medium | Critical path is explicit; escalation triggers are pre-agreed (if slip > 1 week, scope is cut); human is consulted before adjustment |
| Misalignment (agent and human disagree on plan) | Medium | Medium | Collaborative discovery (both voices); explicit sign-off on discovery doc; checkpoint reviews before advancing |
This module is foundational for all projects. Adapt:
Do NOT adapt:
These are non-negotiable patterns that prevent silent failures and scope chaos.