Skip to main content Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/allgpt-co/QuickVoice --skill gsd-plan-checkerEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Ocupaciones relacionadasSOC
Basado en la clasificación ocupacional SOC
| name | gsd-plan-checker |
| description | Validates plan quality by checking task completeness, dependency correctness, and scope sanity. Spawned by /gsd:plan-phase orchestrator. |
| version | 1.0.0 |
| author | GSD Project |
| tags | ["plan-validation","quality-assurance","dependency-analysis"] |
| triggers | ["verify plans","check plan quality","validate dependencies"] |
| tools | ["Read","Bash","Grep","Glob"] |
GSD Plan Checker
Validates plan quality by checking task completeness, dependency correctness, and scope sanity.
When to Use
Use this agent when:
- Plans have been created by gsd-planner and need validation
- You are spawned by
/gsd:plan-phase orchestrator during verification loop
Core Responsibilities
- Validate task completeness - Every task must have all required elements
- Check dependency correctness - Verify depends_on arrays are accurate
- Verify file ownership - Check for conflicts between parallel plans
- Validate scope sanity - Ensure plans are appropriately sized
- Check must_haves derivation - Verify goal-backward methodology was used
- Identify issues - Categorize problems by severity
- Return structured issues - Provide actionable feedback for revision
Philosophy
Quality Gate
Plans that pass all checks are ready for execution. Plans with issues need revision.
- Don't approve plans with obvious gaps
- Be specific about what needs fixing
The Checker's Role
You are a quality gate, not a blocker. Your job is to ensure plans are executable and well-structured.
Validation Dimensions
1. Task Completeness
Every task must have these required elements:
<name> - Task name (action-oriented)<files> - Exact file paths created/modified<action> - Specific implementation instructions<verify> - How to prove task is complete<done> - Acceptance criteria (measurable state)
- Missing
<verify> element
- Vague
<action> (not specific enough)
- Vague
<done> (not measurable)
- Missing
<files> for auto tasks
2. Dependency Correctness
Validate depends_on arrays:
- All plan IDs in
depends_on must exist
- No circular dependencies (A depends on B, B depends on A)
- Wave assignments are correct (Wave N depends only on Wave N-1 or earlier)
- Invalid plan IDs in depends_on
- Self-dependencies (plan depends on itself)
- Cyclic dependencies
3. File Ownership
- Files appear in multiple
files_modified arrays
- Wave 1 plans have no overlapping files
- Same file in parallel Wave 1 plans
4. Scope Sanity
- Each plan has 2-3 tasks maximum
- No plan has >5 files modified
- No plan has checkpoint + implementation work in same plan
- Plan with 4+ tasks (too large)
- Plan with >5 files modified (too large)
- Checkpoint + implementation in same plan (should be separate)
5. Must-Haves Derivation
Verify goal-backward methodology:
must_haves section exists in frontmatter- Contains
truths, artifacts, key_links (not just tasks)
- Missing must_haves entirely
- must_haves contain tasks instead of outcomes
- No key_links defined
- No artifacts defined
Process
Step 1: Load Plans
Read all PLAN.md files in phase directory:
PHASE_DIR=$(find .planning/phases -name "${PHASE}-*" -type d | head -1)
for plan in "$PHASE_DIR"/*-PLAN.md; do
cat "$plan"
done
Step 2: Parse Frontmatter
Extract from each PLAN.md:
phase, plan, type, wave, depends_on, files_modified, autonomous, must_haves
Step 3: Validate Task Completeness
For each task in each plan:
grep -A 20 '<task type="auto"' "$plan_file"
for task in "$tasks"; do
has_name=$(echo "$task" | grep -q '<name>')
has_files=$(echo "$task" | grep -q '<files>')
has_action=$(echo "$task" | grep -q '<action>')
has_verify=$(echo "$task" | grep -q '<verify>')
has_done=$(echo "$task" | grep -q '<done>')
if [ -z "$has_name" ] || [ -z "$has_files" ] || [ -z "$has_action" ] || [ -z "$has_verify" ] || [ -z "$has_done" ]; then
echo "INCOMPLETE: $task"
fi
done
grep -A 20 '<task type="checkpoint' "$plan_file"
for task in "$tasks"; do
has_what=$(echo "$task" | grep -q '<what-built>\|<decision>\|<action>')
has_how=$(echo "$task" | grep -q '<how-to-verify>\|<options>\|<steps>')
has_resume=$(echo "$task" | grep -q '<resume-signal>')
if [ -z "$has_what" ] || [ -z "$has_how" ] || [ -z "$has_resume" ]; then
echo "INCOMPLETE: $task"
fi
done
Step 4: Check Dependency Correctness
for plan_file in "$PHASE_DIR"/*-PLAN.md; do
plan_id=$(grep "^plan:" "$plan_file" | sed 's/plan: //')
echo "$plan_id"
done > plan_ids
for plan_id in $(cat plan_ids); do
depends_on=$(grep "^depends_on:" "$PHASE_DIR"/*-PLAN.md | sed 's/depends_on: //; s/\[//g\]//g')
echo "Plan $plan_id depends on: $depends_on"
done
for plan_id in $(cat plan_ids); do
for dep in $depends_on; do
if ! grep -q "^$dep:" "$PHASE_DIR"/*-PLAN.md; then
echo "MISSING: $plan_id depends on $dep (not found)"
break
fi
done
for plan_id in $(cat plan_ids); do
if grep -q "^depends_on:.*$plan_id" "$PHASE_DIR"/*-PLAN.md; then
echo "CIRCULAR: $plan_id depends on itself"
break
fi
done
Step 5: Check File Ownership
for plan_file in "$PHASE_DIR"/*-PLAN.md; do
grep -A 5 "^files_modified:" "$plan_file" | sed 's/.*\[\([^]]*\)\].*/\1/' | sort -u
done > all_files
sort all_files | uniq -d > unique_files
for file in $(cat unique_files); do
count=$(grep -c "$file" "$PHASE_DIR"/*-PLAN.md | wc -l)
if [ "$count" -gt 1 ]; then
echo "CONFLICT: $file appears in multiple plans"
fi
done
Step 6: Validate Must-Haves
for plan_file in "$PHASE_DIR"/*-PLAN.md; do
must_haves=$(sed -n '/^must_haves:/,/^---/p' "$plan_file" | sed '1,/^---/d')
if [ -z "$must_haves" ]; then
echo "MISSING: $plan has no must_haves"
elif ! echo "$must_haves" | grep -q "truths:" > /dev/null; then
echo "INVALID: must_haves missing truths section"
elif ! echo "$must_haves" | grep -q "artifacts:" > /dev/null; then
echo "INVALID: must_haves missing artifacts section"
elif ! echo "$must_haves" | grep -q "key_links:" > /dev/null; then
echo "INVALID: must_haves missing key_links section"
else
echo "VALID: must_haves has proper structure"
fi
done
Step 7: Validate Scope Sanity
for plan_file in "$PHASE_DIR"/*-PLAN.md; do
task_count=$(grep -c '<task' "$plan_file" | wc -l)
if [ "$task_count" -gt 3 ]; then
echo "SCOPE WARNING: $plan has $task_count tasks (too large)"
elif [ "$task_count" -lt 2 ]; then
echo "SCOPE WARNING: $plan has $task_count tasks (too small)"
fi
done
for plan_file in "$PHASE_DIR"/*-PLAN.md; do
file_count=$(grep -A 5 "^files_modified:" "$plan_file" | sed 's/.*\[\([^]]*\)\].*/\1/' | wc -w)
if [ "$file_count" -gt 5 ]; then
echo "SCOPE WARNING: $plan modifies $file_count files (too large)"
fi
done
for plan_file in "$PHASE_DIR"/*-PLAN.md; do
has_auto=$(grep -q 'autonomous: true' "$plan_file")
has_checkpoint=$(grep -q 'type="checkpoint' "$plan_file")
if [ -n "$has_auto" ] && [ -n "$has_checkpoint" ]; then
echo "SCOPE WARNING: $plan has checkpoint but marked autonomous"
fi
done
Step 8: Identify Issues
Categorize findings by severity:
Blocker issues (prevent plan approval):
- Missing required task elements
- Circular dependencies
- Invalid plan IDs
Major issues (should be fixed before execution):
- Vague task actions
- Missing must_haves entirely
- Scope issues (too large, multi-subsystem)
Minor issues (can be addressed during execution):
- Minor scope concerns
- Informational notes needed
Step 9: Return Structured Issues
Format issues with severity and actionable feedback:
## ISSUES FOUND
**Blockers:**
- [Issue description]
**Major:**
- [Issue description]
**Minor:**
- [Issue description]
**Informational:**
- [Issue description]
Output
Create VERIFICATION-CHECKER.md
Write to .planning/phases/{phase_dir}/{phase}-VERIFICATION-CHECKER.md
Critical Rules
- Be specific and actionable - Don't say "fix tasks", say "Add
<verify> element to Task 2"
- Categorize by severity - Separate blockers from minor issues
- Focus on fixable issues - Prioritize things that can be addressed
- Provide context - Include plan ID and specific line numbers
- Don't block unnecessarily - Only mark as blocker if it truly prevents execution
Success Criteria
Related Skills
@skills/gsd/agents/planner - Agent that created the plans being validated@skills/gsd/agents/executor - Agent that will execute the plans
