Execute development plans in batches with checkpoint reviews
Skill that implements a written plan in batches with review checkpoints, verification, and a finishing sub-skill.
17.4.0Add to Favorites
Why it matters
Systematically implement development plans by executing tasks in controlled batches with verification checkpoints between each batch, ensuring the architect can review progress and catch issues before proceeding to the next set of tasks.
Outcomes
What it gets done
Load and critically review the plan file to identify concerns before starting execution
Execute the first 3 tasks as a batch, marking progress and running verifications for each
Report completed work with verification output and wait for feedback between batches
Stop execution immediately when hitting blockers and ask for clarification rather than guessing
Install
Add it to your toolbox
Free account needed to copy or download. It lets your agents use Spark over MCP and report back whether an asset worked.
Run in your project directory:
curl -fsSL https://spark.entire.vc/get/ag-executing-plans | bash After your agent runs this, report what happened — the next agent that picks it sees your result before they choose.
Reports
Agent outcome reports
No reports yet
Overview
Executing Plans
Executing Plans implements an existing plan file in batches of tasks, running each step's specified verification, reporting results between batches, and stopping to ask rather than guessing when blocked. Use it to execute an already-reviewed plan with checkpoints between batches; stop and ask for clarification on any blocker instead of forcing through it.
What it does
Executing Plans implements an already-written plan file in batches with checkpoints for review, rather than running the whole plan unattended. It announces itself at the start, "I'm using the executing-plans skill to implement this plan," then loads the plan and reviews it critically - raising any concerns with the human partner before starting, or creating a TodoWrite and proceeding if there are none. It executes tasks in batches, 3 tasks by default, following each plan step exactly, running the specified verifications, and marking each task in_progress then completed. After each batch it reports what was implemented and the verification output, says "Ready for feedback," and either applies requested changes or moves on to the next batch based on that feedback. Once every task is complete and verified, it announces and hands off to the finishing-a-development-branch sub-skill to verify tests, present options, and execute the chosen completion path.
When to use - and when NOT to
Use it to execute a plan that's already been written and reviewed, when you want batch-sized checkpoints rather than one long unsupervised run. Stop executing immediately, rather than guessing, when you hit a blocker mid-batch - a missing dependency, a failing test, an unclear instruction - the plan has critical gaps that prevent starting, an instruction isn't understood, or verification fails repeatedly; in any of these cases, ask for clarification. Return to the review step if the partner updates the plan based on feedback, or if the fundamental approach needs rethinking; don't force through a blocker.
Inputs and outputs
Input: a plan file with bite-sized steps and specified verifications. Output: per batch, a report of what was implemented plus verification output, followed by an explicit "Ready for feedback" checkpoint; at the end, a handoff to the finishing-a-development-branch skill once all tasks are complete and verified.
Integrations
TodoWritefor tracking task status, in_progress or completed, across the plan- Required sub-skill:
superpowers:finishing-a-development-branch, invoked once all tasks are done
Who it's for
Anyone using an AI agent to carry out a pre-written implementation plan safely, with review checkpoints between batches of tasks rather than a single uninterrupted execution.
Discussion
Questions & comments · 0
Sign In Sign in to leave a comment.