executing-plans（执行计划）

Executing Plans

Overview

This skill turns an approved plan document into working code through disciplined, batch-based execution. Each step is implemented with TDD, verified before proceeding, and reviewed at checkpoints. It provides the structural framework for moving from plan to production code with consistent quality gates.

Announce at start: "I'm using the executing-plans skill to implement the approved plan at [plan path]."

Trigger Conditions

• An approved plan document exists and is ready for implementation
• /execute command invoked with a plan reference
• Resuming a partially completed plan execution
• Transition from planning skill after plan approval

Phase 1: Read the Plan

Goal: Thoroughly understand the plan before writing any code.

1. Read the entire plan document from start to finish
2. Identify all implementation steps and count them
3. Map dependencies between steps (what must be done first)
4. Note any ambiguities or open questions
5. Confirm understanding with the user before proceeding

Plan Comprehension Checklist

STOP — Do NOT proceed to Phase 2 until:

• You can explain the plan's goal in one sentence
• You can list all implementation steps
• Dependencies are mapped
• Any ambiguities are noted and resolved with user
• User has confirmed you may proceed

Phase 2: Create Task Batch

Goal: Break the plan into small, executable task batches.

Batch Size Decision Table

Task Requirements (STIC)

Task Template

Task: [concise description]
Plan Step: [reference to plan section]
Files to Create/Modify: [list of exact file paths]
Acceptance Criteria:
  - [specific, testable criterion 1]
  - [specific, testable criterion 2]
Dependencies: [other tasks that must be done first, or "none"]
Verification: [exact command to run]

STOP — Do NOT proceed to Phase 3 until:

• Tasks created for the current batch
• Each task has clear acceptance criteria
• Dependencies are satisfied (previous tasks complete)
• Tasks ordered by dependency (independent tasks first)

Phase 3: Execute Tasks

Goal: Execute each task one at a time using TDD.

Per-Task Workflow

1. ANNOUNCE which task you are starting
2. IMPLEMENT using test-driven-development skill:
   a. Write failing test (RED)
   b. Write minimal code to pass (GREEN)
   c. Refactor (REFACTOR)
   d. Repeat RED-GREEN-REFACTOR for each behavior
3. VERIFY using verification-before-completion skill:
   a. Run full test suite (not just new tests)
   b. Run lint, type-check, build as applicable
   c. Confirm all checks pass
4. MARK task as complete
5. PROCEED to next task

Execution Rules

Task Outcome Decision Table

STOP — Do NOT proceed to next task until:

• Current task's acceptance criteria are met
• All tests pass (new and existing)
• Verification-before-completion has been executed
• Task marked as complete

Phase 4: Batch Checkpoint

Goal: After completing all tasks in a batch, perform a full checkpoint review.

Checkpoint Steps

1. Run full test suite — all tests, not just those from the current batch
2. Run all verification commands — lint, type-check, build, format
3. Review what was implemented — summarize completed tasks and outcomes
4. Assess progress against the plan — how far through are we?
5. Identify any issues or risks that came up during execution
6. Report to user and ask for direction

Checkpoint Report Template

BATCH CHECKPOINT
================
Batch: [N] of [estimated total]
Tasks Completed: [list]

Verification Results:
  Tests:      [X passed, Y failed, Z skipped]
  Build:      [pass/fail]
  Lint:       [pass/fail, N warnings]
  Type-check: [pass/fail]

Progress: [N of M plan steps complete] ([percentage]%)

Issues Encountered:
  - [issue 1 and how it was resolved]

Risks or Concerns:
  - [risk 1]

Next Batch Preview:
  - [task 1]
  - [task 2]
  - [task 3]

Awaiting direction: Continue with next batch / Adjust plan / Other?

STOP — Do NOT proceed to next batch until:

• Full test suite passes
• All verification commands pass
• Checkpoint report presented to user
• User has confirmed to continue

Phase 5: Continue, Adjust, or Complete

Goal: Act on user direction after each checkpoint.

Direction Decision Table

Never proceed to the next batch without explicit user approval.

Critical Blocker Handling

When you encounter something that prevents task completion, do NOT work around it. Stop and escalate.

Blocker Classification

Blocker Report Format

CRITICAL BLOCKER
================
Task: [which task is blocked]
Blocker: [clear description of the problem]
Impact: [what cannot proceed until this is resolved]
Options:
  A. [option with tradeoffs]
  B. [option with tradeoffs]
  C. [skip this step and continue]

Awaiting direction before proceeding.

Do NOT guess what the user intended. Do NOT implement a workaround without approval. Do NOT skip the blocked task silently. DO present options with clear tradeoffs. DO continue with non-blocked tasks if possible (but flag the skip).

Subagent Dispatch Option

For larger plans, individual tasks can be dispatched to subagents for parallel execution.

When to Suggest Subagent Dispatch

When conditions are met, suggest switching to the subagent-driven-development skill for the remaining work.

Anti-Patterns / Common Mistakes

Anti-Rationalization Guards

If you catch yourself thinking:

• "I know what comes next, I'll skip the checkpoint..." — No. Report and wait.
• "This verification is redundant..." — Run it anyway. Fresh evidence only.
• "The plan is close enough, I'll adjust as I go..." — Discuss adjustments first.

Subagent Dispatch Opportunities

Follow the dispatching-parallel-agents skill protocol when dispatching.

Integration Points

Concrete Examples

Example: Batch Creation from Plan

Plan: "Add user authentication with JWT"

Batch 1 (3 tasks):
  Task 1: Write failing test for JWT token generation
    Files: tests/auth/jwt.test.ts
    Verification: npm test -- --grep "JWT generation" → FAIL (expected)

  Task 2: Implement JWT token generation
    Files: src/auth/jwt.ts
    Verification: npm test -- --grep "JWT generation" → PASS

  Task 3: Write failing test for auth middleware
    Files: tests/middleware/auth.test.ts
    Verification: npm test -- --grep "auth middleware" → FAIL (expected)

[CHECKPOINT after batch 1]

Batch 2 (3 tasks):
  Task 4: Implement auth middleware
  Task 5: Write failing test for login endpoint
  Task 6: Implement login endpoint

[CHECKPOINT after batch 2]

Completion Criteria

The plan execution is complete when:

1. All plan steps have been implemented as tasks
2. All tasks have passed verification
3. Full test suite passes
4. Final checkpoint report presented to user
5. User confirms the plan is complete

Skill Type

RIGID — Follow this process exactly. Batches, checkpoints, and verification gates are non-negotiable. No task is complete without verification. No batch proceeds without user approval.