executing-plans · Inline Plan Execution

executing-plans executes an implementation plan task by task, inline in the current session: the plan is read once, every task runs to completion without check-in interruptions. Each task goes through TDD (watch the test fail, then pass) with expected outputs verified per step, and progress is recorded in a ledger file that survives context compaction.

Plan/spec conflicts are ruled against the spec and logged. It closes with one fresh review of the whole branch: Critical/Important findings get a single fix pass (each verified RED→GREEN), Minors are logged.

Example invocation: "Execute this implementation plan."

Full brief

Positioning

executing-plans is the inline executor for implementation plans: given a plan from writing-plans, it runs every task to completion in this session — no subagents, no per-task reviews, one fresh review of the whole branch at the end. The plan's thinking becomes a verified commit sequence.

Core capabilities

• Continuous execution: all tasks run without "should I continue?" interruptions; conflicts and ambiguities are ruled on (logged as Rulings); only four things stop it — irreversible operations, security-sensitive actions, external side effects (merging to main, pushing shared branches), and a plan broken beyond repair.
• TDD per-task gate: every step writes the failing test first, watches it fail, then implements and watches it pass; every Expected: line is compared against real output.
• Progress ledger: each plan owns an isolated workspace with progress.md; each task completion (commit range + test results) and each deviation from the plan (a Ruling) is a ledger line; after compaction, the ledger and git log are the source of truth.
• Pre-flight scan: interface conflicts between tasks are scanned before Task 1, ruled against the spec.
• Completion contract: before a task closes, every test the brief names exists and ran, the final run passed, every Expected was compared, every deviation has a Ruling.
• Closing fresh review: one new-context review of the whole branch (strongest available model if a subagent tool exists); findings re-graded by impact; Critical/Important get one fix pass (each RED→GREEN with a green suite); Minors go to the ledger; the plan workspace is then deleted.

Workflow

1. Setup: isolated workspace (with using-git-worktrees) + ledger; read plan and spec; pre-flight interface scan
2. Task loop: task-start reads the brief → TDD through the steps → compare Expected → commit as planned → task-done records completion
3. Fresh review of the whole branch
4. One fix pass for Critical/Important (each RED→GREEN, suite stays green); Minors logged
5. Finish: delete the plan workspace, hand to finishing-a-development-branch

Inputs & outputs

Output: the plan's commit sequence + ledger (progress.md with completions and all Rulings) + whole-branch review findings and fix record.

Boundaries with adjacent skills

• brainstorming / writing-plans: produce the plan and spec upstream; this skill turns the plan into commits.
• subagent-driven-development: a fresh subagent plus reviewer per task — costlier, more isolated; this skill trades that for one context plus a final review.
• requesting-code-review: invoked by this skill's closing whole-branch review stage.

Fit

• A complete plan ready to run start-to-finish without confirmations
• Plans with mostly independent, sequential tasks
• Environments without a subagent tool, or where context and cost matter
• Long plans needing recoverable progress across compaction

Before you start

• No API key.
• Needs an implementation plan from writing-plans (rulings without a spec are provisional).
• Runs in an isolated workspace (with using-git-worktrees); git required; never implements directly on main.
• Stops for: irreversible operations, security-sensitive actions, external side effects like merging to main, and unfixable plans.

executing-plans is part of the Aiglade Skill library. Invoke it from the Aiglade chat box in plain language.

← All 155 skills