executing-plans_skill

Overview

This skill implements a partner-provided plan by loading it, reviewing it critically, and executing tasks in controlled batches with review checkpoints. The core principle is batch execution with explicit verification and feedback pauses to avoid guessing and reduce risk. It includes clear stop rules and a required finishing sub-skill for finalization.

How this skill works

First, the skill loads the plan file and performs a critical review, raising any questions before execution. It then executes a default initial batch (first three tasks) by marking tasks in_progress, following the plan steps exactly, running specified verifications, and marking tasks completed. After each batch it reports results and verification output, waits for feedback, applies requested changes, and repeats until the plan is complete. On finalization it invokes the finishing-a-development-branch sub-skill to run final checks and present options.

When to use it

• A partner provides a complete, step-by-step implementation plan and wants controlled execution.
• You need to run work in small batches with verification and human review between batches.
• Risk of incorrect assumptions is high and explicit feedback checkpoints are required.
• When plan steps include built-in verifications that must not be skipped.
• When the workflow requires a formal handoff to a finishing procedure at the end.

Best practices

• Always perform a critical review of the plan and raise clarifying questions before starting.
• Execute small batches (default first three tasks) and never skip specified verifications.
• Mark task states (in_progress, completed) clearly and report verification output after each batch.
• Stop immediately and ask for clarification on blockers, unclear instructions, or failing verifications.
• Use the finishing-a-development-branch sub-skill at completion to verify tests and finalize changes.

Example use cases

• Implementing a multi-step feature where each step has unit tests or smoke checks attached.
• Applying infrastructure changes in stages with human approval between batches.
• Executing a migration plan that must be validated incrementally to avoid data loss.
• Running an onboarding checklist for a new module that requires sign-off after each subset of tasks.