The executing-plans Skill — Running a Written Plan Step by Step
How Datarim turns a written implementation plan into tracked, verified execution — with explicit checkpoints, a stop-and-ask rule, and a mandatory finishing phase.
A written plan only has value if it is followed as written. The executing-plans skill defines how to load a plan, review it before touching any code, and execute each task with explicit status tracking and evidence requirements.
The skill is designed for single-session execution. When the runtime supports spawning isolated agents, subagent-driven-development is preferred — independent agents handling implementation and review separately improve structured execution quality. For linear single-agent work, executing-plans is the right tool.
Step 1 — Review before starting
The plan file is read first. Any question or concern about its content surfaces before a single task begins. The skill explicitly allows for this review to surface problems — a plan with critical gaps preventing a start should be addressed rather than worked around. If no concerns arise, the plan's tasks are enumerated as a working checklist: each task gets an explicit [ ] / [~] / [✓] status, and execution begins.
Step 2 — Execute with tracking
Each task is marked in-progress before any work on it starts, so the operator always knows what is active. The plan steps are followed exactly — the skill is not an invitation to reinterpret the plan's approach mid-execution. Verifications specified in the plan run as written. A task is marked complete only when its verification passes; the evidence — command output, file path, test result — is recorded inline in the checklist.
When a blocker appears — a missing dependency, a failing test that does not resolve, an unclear instruction — execution stops immediately. The skill does not permit guessing through a blocker. The operator provides clarification and execution resumes from the stopped point.
Step 3 — Finishing phase
After all tasks are verified, the skill hands off to finishing-a-development-branch. This is a required sub-skill, not optional. It covers the actions that close out a branch: verifying tests pass, confirming the branch is clean, and presenting the operator with next steps. Execution does not end at the last checklist item — it ends at the close of the finishing phase.
One concrete example
A plan has six tasks: scaffold the module, add unit tests, implement the function, run the test suite, check the types compile, and update the changelog. The checklist starts with all six at [ ]. After implementing the function, the test suite fails on a missing import. Execution stops. The operator points to the correct import path. Execution resumes with the fix applied, the test suite reruns, passes, and the task is marked [✓] with the test output recorded as evidence.
See also the writing-plans skill post for how the plan this skill executes gets created, and what Datarim is for the full pipeline context.