Executing Plans
Overview
Load plan, review critically, execute all tasks, report when complete.
Announce at start: "I'm using the executing-plans skill to implement this plan."
For non-trivial execution, include Aegis Visibility: briefly tie the active
slice to its plan, checkpoint, drift or verification boundary. At completion,
pass plan adherence, evidence, complexity and residual risk to
verification-before-completion for the unified receipt.
If subagents are available and the plan has genuinely independent tasks,
prefer subagent-driven-development; lack of subagent support does not block
inline execution. Same-task agents share one workspace, and the coordinator
remains the only Git mutation owner.
The Process
Step 1: Load and Review Plan
- Read plan file
- If the plan or active checkpoint includes an
Execution Readiness View,
read it before implementation and compare the plan against its intent lock,
scope fence, baseline lock, owner / contract constraints, compatibility
boundary, retirement boundary, test obligations, review gates, drift /
rewind rules, and evidence required before completion.
- Review critically - identify any questions or concerns about the plan
- If the view contradicts the plan, baseline, or current worktree evidence,
return to plan review or refresh the advisory handoff before editing.
- Run the TDD Route Guard before implementation: confirm
Mode, Decision, Strict authority,
strict signals, light eligibility, Test posture, and verification. Strict
steps require either an explicit user/project request or a recorded auto
decision; plan approval or risk labels alone are not authority. An
off-mode missing record may be repaired only as Mode: off / Decision: skipped without loading TDD. Missing/unsupported auto decisions return to
plan review. An auto-light record is unsupported when any strict signal is
present or when its tiny/low-risk/single-owner/no-behavior-change proof is
incomplete. Only Decision: strict with recorded strict authority may
authorize steps named Write failing test, Verify RED, GREEN, or
REFACTOR. Do not infer strict during execution.
- If concerns: Raise them with your human partner before starting
- Before the first write, capture
TaskStartSnapshot: root, HEAD, branch or
detached state, upstream divergence, staged/unstaged/untracked paths, active
Git operations, and git worktree list --porcelain. Preserve task-preexisting
state; do not stash, reset, clean, or commit it.
- Reuse the current branch unless rules require independent history or another
goal owns it. If justified, switch/create it in the
current workspace when safe; a worktree still requires
concurrent checkout or blocking dirty state.
- If no concerns: Create TodoWrite and proceed
Step 1.5: Long-Task Checkpoint Setup
If the plan has multiple tasks, may span sessions, or includes architecture / contract / workflow changes:
- Announce: "I'm using the long-task-continuation skill to keep this plan checkpointed and drift-aware."
- Load aegis:long-task-continuation.
- Create the initial checkpoint from the plan:
- current todo
- active task
- completed tasks
- evidence refs
- blockers
- next step
- Before each task, restate the current checkpoint.
- After each task, update checkpoint, evidence refs, and drift check.
Before a verification-driven unplanned edit, read retained PatchShape,
CanonicalOwner, UpwardDrillSignal, outcome, and evidence refs. Route their
comparison with the candidate to systematic-debugging before editing; it
decides whether the directions converge. A proven independent canonical-owner
root stays on the normal plan path.
Step 2: Execute Tasks
For each task:
Mark as in_progress
Follow each step exactly (plan has bite-sized steps)
Before any new source-code path is added by a task, restate the plan's
Change Necessity or create a compact one if the plan failed to carry it
forward. Plan approval is not by itself proof that a new helper, small guard,
new branch, fallback, adapter, or owner is necessary.
Change Necessity:
- User-visible need:
- No-change / non-code option:
- Why code change is necessary:
- Minimum change boundary:
- Decision: no-change | docs/config-only | code-change | needs-clarification
If the decision is not code-change, pause execution and return to plan
review instead of editing. If the decision is code-change, carry the
minimum boundary into the edit and verification scope.
Before any non-trivial source edit, run the plan's
Pre-Edit Complexity Check or create a compact one:
Use using-aegis/references/complexity-governance.md for shared artifact
classes, pressure signals, and over-budget handling.
Complexity Budget:
- Artifact class:
- Target files / artifacts:
- Current pressure:
- Projected post-change pressure:
- Budget result: within-budget | at-risk | over-budget
- Planned governance:
Pre-Edit Complexity Check:
- Target edit file:
- Existing pressure signal:
- Safer edit boundary:
- Decision: edit-in-place | extract helper | add owner file | split task | pause for plan update
Pre-Edit Owner-Fit Decision:
- Edit intent: wiring-only | move-out / extract-first | local-fix-without-new-responsibility | new-responsibility | emergency / compatibility patch
- Owner fit:
- Safer edit boundary:
- Decision: edit-in-place | extract helper | add owner file | split task | pause for plan update
If the check contradicts the plan's file boundary, pause and return to plan
review instead of silently stuffing logic into an overloaded owner. If the
budget result is over-budget and the task does not also govern that
overrun, stop execution and return to plan review rather than pushing the
task through as if it were still atomic.
When the target edit file is over-budget or mixed-purpose,
new-responsibility must not be added in place by default. wiring-only,
move-out / extract-first, and local-fix-without-new-responsibility may
proceed only when they do not add a new responsibility and the verification
boundary is clear. emergency / compatibility patch requires residual risk
and a retirement trigger.
Run verifications as specified
The coordinator is the Git mutation owner. After the coherent Task passes
its planned verification, use verification-before-completion before a
default local commit, stage only task-owned paths, and read back HEAD, the
committed file list, and remaining task delta. no commit, read-only,
no-change, and failed-verification tasks create no normal commit.
Update TodoCheckpointDraft and DriftCheckDraft before marking the task completed.
When an Execution Readiness View exists, the drift check must explicitly
compare the active slice against the view's intent lock, scope fence,
baseline lock, compatibility boundary, retirement boundary, test
obligations, and review gates.
Mark as completed
Step 3: Complete Development
After all tasks complete and verified:
- if Aegis created a branch/worktree or the user requests integration handling,
use
aegis:finishing-a-development-branch;
- otherwise use
verification-before-completion, report the local task commit
and Task clean / Repository clean, and do not invent merge/PR ceremony.
When to Stop and Ask for Help
STOP executing immediately when:
- Hit a blocker (missing dependency, test fails, instruction unclear)
- Plan has critical gaps preventing starting
- You don't understand an instruction
- Verification fails repeatedly
Ask for clarification rather than guessing.
When to Revisit Earlier Steps
Return to Review (Step 1) when:
- Partner updates the plan based on your feedback
- Fundamental approach needs rethinking
Don't force through blockers - stop and ask.
Remember
- Review plan critically first
- Follow plan steps exactly
- Don't skip verifications
- Reference skills when plan says to
- Stop when blocked, don't guess
- Do not create a branch merely because the current branch is
main/master
- Do not let task complexity, TDD, planning, or subagents alone trigger a worktree
Integration
Required workflow skills:
- aegis:writing-plans - Creates the plan this skill executes
- aegis:using-git-worktrees - Only when the approved Git lifecycle says a concurrent checkout is necessary
- aegis:finishing-a-development-branch - Only when branch/worktree integration or cleanup is in scope
1---
2name: executing-plans
3description: "Use when executing a written implementation plan across sessions or with review checkpoints. Small or single-slice plans stay inline. For same-session independent tasks, use subagent-driven-development instead."
4metadata:
5 source: https://skillmd.com/skills/ganyuanran/executing-plans
6---
7
8# Executing Plans
9
10## Overview
11
12Load plan, review critically, execute all tasks, report when complete.
13
14**Announce at start:** "I'm using the executing-plans skill to implement this plan."
15
16For non-trivial execution, include `Aegis Visibility`: briefly tie the active
17slice to its plan, checkpoint, drift or verification boundary. At completion,
18pass plan adherence, evidence, complexity and residual risk to
19`verification-before-completion` for the unified receipt.
20
21If subagents are available and the plan has genuinely independent tasks,
22prefer `subagent-driven-development`; lack of subagent support does not block
23inline execution. Same-task agents share one workspace, and the coordinator
24remains the only Git mutation owner.
25
26## The Process
27
28### Step 1: Load and Review Plan
291. Read plan file
302. If the plan or active checkpoint includes an `Execution Readiness View`,
31 read it before implementation and compare the plan against its intent lock,
32 scope fence, baseline lock, owner / contract constraints, compatibility
33 boundary, retirement boundary, test obligations, review gates, drift /
34 rewind rules, and evidence required before completion.
353. Review critically - identify any questions or concerns about the plan
364. If the view contradicts the plan, baseline, or current worktree evidence,
37 return to plan review or refresh the advisory handoff before editing.
385. Run the TDD Route Guard before implementation: confirm `Mode`, `Decision`, `Strict authority`,
39 strict signals, light eligibility, `Test posture`, and verification. Strict
40 steps require either an explicit user/project request or a recorded auto
41 decision; plan approval or risk labels alone are not authority. An
42 off-mode missing record may be repaired only as `Mode: off / Decision:
43 skipped` without loading TDD. Missing/unsupported auto decisions return to
44 plan review. An auto-light record is unsupported when any strict signal is
45 present or when its tiny/low-risk/single-owner/no-behavior-change proof is
46 incomplete. Only `Decision: strict` with recorded strict authority may
47 authorize steps named `Write failing test`, `Verify RED`, `GREEN`, or
48 `REFACTOR`. Do not infer `strict` during execution.
496. If concerns: Raise them with your human partner before starting
507. Before the first write, capture `TaskStartSnapshot`: root, `HEAD`, branch or
51 detached state, upstream divergence, staged/unstaged/untracked paths, active
52 Git operations, and `git worktree list --porcelain`. Preserve task-preexisting
53 state; do not stash, reset, clean, or commit it.
548. Reuse the current branch unless rules require independent history or another
55 goal owns it. If justified, switch/create it in the
56 current workspace when safe; a worktree still requires
57 concurrent checkout or blocking dirty state.
589. If no concerns: Create TodoWrite and proceed
59
60### Step 1.5: Long-Task Checkpoint Setup
61
62If the plan has multiple tasks, may span sessions, or includes architecture / contract / workflow changes:
63
641. Announce: "I'm using the long-task-continuation skill to keep this plan checkpointed and drift-aware."
652. Load aegis:long-task-continuation.
663. Create the initial checkpoint from the plan:
67 - current todo
68 - active task
69 - completed tasks
70 - evidence refs
71 - blockers
72 - next step
734. Before each task, restate the current checkpoint.
745. After each task, update checkpoint, evidence refs, and drift check.
75
76Before a verification-driven unplanned edit, read retained `PatchShape`,
77`CanonicalOwner`, `UpwardDrillSignal`, outcome, and evidence refs. Route their
78comparison with the candidate to `systematic-debugging` before editing; it
79decides whether the directions converge. A proven independent canonical-owner
80root stays on the normal plan path.
81
82### Step 2: Execute Tasks
83
84For each task:
851. Mark as in_progress
862. Follow each step exactly (plan has bite-sized steps)
873. Before any new source-code path is added by a task, restate the plan's
88 `Change Necessity` or create a compact one if the plan failed to carry it
89 forward. Plan approval is not by itself proof that a new helper, small guard,
90 new branch, fallback, adapter, or owner is necessary.
91
92 ```text
93 Change Necessity:
94 - User-visible need:
95 - No-change / non-code option:
96 - Why code change is necessary:
97 - Minimum change boundary:
98 - Decision: no-change | docs/config-only | code-change | needs-clarification
99 ```
100
101 If the decision is not `code-change`, pause execution and return to plan
102 review instead of editing. If the decision is `code-change`, carry the
103 minimum boundary into the edit and verification scope.
1044. Before any non-trivial source edit, run the plan's
105 `Pre-Edit Complexity Check` or create a compact one:
106
107 Use `using-aegis/references/complexity-governance.md` for shared artifact
108 classes, pressure signals, and `over-budget` handling.
109
110 ```text
111 Complexity Budget:
112 - Artifact class:
113 - Target files / artifacts:
114 - Current pressure:
115 - Projected post-change pressure:
116 - Budget result: within-budget | at-risk | over-budget
117 - Planned governance:
118
119 Pre-Edit Complexity Check:
120 - Target edit file:
121 - Existing pressure signal:
122 - Safer edit boundary:
123 - Decision: edit-in-place | extract helper | add owner file | split task | pause for plan update
124
125 Pre-Edit Owner-Fit Decision:
126 - Edit intent: wiring-only | move-out / extract-first | local-fix-without-new-responsibility | new-responsibility | emergency / compatibility patch
127 - Owner fit:
128 - Safer edit boundary:
129 - Decision: edit-in-place | extract helper | add owner file | split task | pause for plan update
130 ```
131
132 If the check contradicts the plan's file boundary, pause and return to plan
133 review instead of silently stuffing logic into an overloaded owner. If the
134 budget result is `over-budget` and the task does not also govern that
135 overrun, stop execution and return to plan review rather than pushing the
136 task through as if it were still atomic.
137 When the target edit file is over-budget or mixed-purpose,
138 `new-responsibility` must not be added in place by default. `wiring-only`,
139 `move-out / extract-first`, and `local-fix-without-new-responsibility` may
140 proceed only when they do not add a new responsibility and the verification
141 boundary is clear. `emergency / compatibility patch` requires residual risk
142 and a retirement trigger.
1435. Run verifications as specified
1446. The coordinator is the Git mutation owner. After the coherent Task passes
145 its planned verification, use `verification-before-completion` before a
146 default local commit, stage only task-owned paths, and read back `HEAD`, the
147 committed file list, and remaining task delta. `no commit`, read-only,
148 no-change, and failed-verification tasks create no normal commit.
1497. Update `TodoCheckpointDraft` and `DriftCheckDraft` before marking the task completed.
150 When an `Execution Readiness View` exists, the drift check must explicitly
151 compare the active slice against the view's intent lock, scope fence,
152 baseline lock, compatibility boundary, retirement boundary, test
153 obligations, and review gates.
1548. Mark as completed
155
156### Step 3: Complete Development
157
158After all tasks complete and verified:
159
160- if Aegis created a branch/worktree or the user requests integration handling,
161 use `aegis:finishing-a-development-branch`;
162- otherwise use `verification-before-completion`, report the local task commit
163 and `Task clean` / `Repository clean`, and do not invent merge/PR ceremony.
164
165## When to Stop and Ask for Help
166
167**STOP executing immediately when:**
168- Hit a blocker (missing dependency, test fails, instruction unclear)
169- Plan has critical gaps preventing starting
170- You don't understand an instruction
171- Verification fails repeatedly
172
173**Ask for clarification rather than guessing.**
174
175## When to Revisit Earlier Steps
176
177**Return to Review (Step 1) when:**
178- Partner updates the plan based on your feedback
179- Fundamental approach needs rethinking
180
181**Don't force through blockers** - stop and ask.
182
183## Remember
184- Review plan critically first
185- Follow plan steps exactly
186- Don't skip verifications
187- Reference skills when plan says to
188- Stop when blocked, don't guess
189- Do not create a branch merely because the current branch is `main`/`master`
190- Do not let task complexity, TDD, planning, or subagents alone trigger a worktree
191
192## Integration
193
194**Required workflow skills:**
195- **aegis:writing-plans** - Creates the plan this skill executes
196- **aegis:using-git-worktrees** - Only when the approved Git lifecycle says a concurrent checkout is necessary
197- **aegis:finishing-a-development-branch** - Only when branch/worktree integration or cleanup is in scope