Skip to content
Skills Library
Programming · Automation

executing-plans

/executing-plans

Use to execute an approved active .workflow plan with milestone state updates, scoped task ownership, compaction recovery, selective worktree delegation, and one integration path. Do not use for direct fast-path work without a durable plan.

Repository
marketplace ↗
Licence
MIT
Last repository change
22.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use to execute an approved active .workflow plan with milestone state updates, scoped task ownership, compaction recovery, selective worktree delegation, and one integration path. Do not use for direct fast-path work without a durable plan.

Original author description

Use to execute an approved active .workflow plan with milestone state updates, scoped task ownership, compaction recovery, selective worktree delegation, and one integration path. Do not use for direct fast-path work without a durable plan.

How it works

  1. Start Or Resume
  2. Execution Cadence
  3. Semantic Work Routing
  4. Delegation Gate
  5. Evidence Ownership
  6. Completion
Original SKILL.md headings · 65 lines, 680 words
SKILL.md preview
---
name: executing-plans
description: Use to execute an approved active .workflow plan with milestone state updates, scoped task ownership, compaction recovery, selective worktree delegation, and one integration path. Do not use for direct fast-path work without a durable plan.
---

# Executing Plans

Execute the active plan as written. Plan artifacts are authoritative; chat is not. Inherit the primary path, assurance profile, task-wide agent budget, and verification budget from `using-workflow`.

## Start Or Resume

1. Call `workflow_status` once when active state is unknown or context was recovered.
2. Read `manifest.json`, `state.json`, `plan.md`, and the current task's referenced context/decisions.
3. Read `ui-contract.md`, chunk state, or older artifacts only when the current task depends on them.
4. Inspect `git status --short` and preserve unrelated user changes.
5. Continue from the first non-complete task; do not replay completed work.

Use `workflow_plan_update`, `workflow_plan_artifact_write`, and `workflow_plan_complete` when available; manual state/artifact writes are fallback only.

Read [references/execution-state.md](references/execution-state.md) only when updating task/chunk state, delegating a write task, or recovering a complex run.

## Execution Cadence

- Update state at meaningful milestones: task start, material block, review handoff, and task completion.
- Do not write workflow state after every tool call or tiny edit.
- Execute tasks within their allowed scope and record any approved scope change before editing outside it.
- Do not perform opportunistic refactors. A new API/schema/protocol/shared abstraction/layer or a higher change class requires an approved plan update and a renewed commitment reflection before implementation continues.
- For production UI, read the UI contract's reuse receipt before markup/styles. Its exact labels are `Target:`, `Shared primitive:`, `Layout precedent:`, `Decision:`, `Structural verification:`. Treat named reuse as architecture acceptance; stop before a local substitute, duplicate primitive, or unapproved layout deviation.
- For a small user correction, inspect and edit only the touched surface plus directly affected tests; do not restart repository discovery.
- For chunks, root owns dependency order and integration. Never create nested chunks.

## Semantic Work Routing

Exact model and reasoning effort live only in canonical custom-agent TOML files.

- `mechanical`: tiny fully specified transformation; `workflow_implementer`.
- `structured`: bounded implementation with locked approach; `workflow_implementer`.
- `standard`: moderate scoped reasoning; `workflow_implementer_standard`.
- `complex`: architecture or broad implementation inside a defined boundary; `workflow_implementer_complex`.
- `critical`: parent retains final decisions; use an independent risk role only within assurance budget.

Do not launch analysis to restate a decision-complete plan.

## Delegation Gate

At each meaningful task boundary, choose local execution or the best bounded agent role deliberately. Prefer one focused agent for nontrivial diagnosis, multi-surface review, broad read-only exploration, or an implementation task that can proceed independently; these are normal standard-path uses, not exceptional escalation. Keep tiny direct fixes and already-decided single-surface work local. Never fan out by file count, checklist length, number of chunks, or number of applicable skills.

All delegated write work uses a worktree. The worker receives goal, chosen approach, allowed scope, exact edits, non-goals, verification, stop-if-unclear behavior, and report format. If a required named role is unavailable, execute locally unless that independent role was explicitly required.

The agent budget is global across planning, execution, and finalization. Reuse a running agent for focused follow-up. A launch used for exploration cannot be replaced by a fresh implementation or review quota.

## Evidence Ownership

The worker runs scoped checks for its assigned change. The parent verifies output exists, performs minimal diff/scope sanity, and runs only integration or acceptance evidence not already proven by an unchanged worker result. Do not rerun the same command solely because ownership returned to the parent.

After relevant edits, rerun the strongest affected check once. Merge delegated work only after the applicable gate passes.

If implementation materially diverges from the reviewed commitment, call `workflow_plan_commitment_propose` with the new candidate and confirm a revised decision before handoff. Hook enforcement is optional and must not be awaited or treated as a dependency.

## Completion

During active user testing, batch small corrections and avoid full verification after each one. When implementation tasks are complete, set phase to `finalizing`.

- `fast` work should not be in this module.
- `standard` and `assurance` continue to `finalizing-plan` with the remaining task-wide budget.
- After final verification/review succeeds, close the run with `workflow_plan_complete`; `set_phase: complete` alone is insufficient.

Stop execution when all planned tasks are complete or a material unresolved decision requires the user. Do not add polish or new scope during handoff.
Files in this package (2)
  • SKILL.md 5 KB
  • references/execution-state.md 2 KB

Versions

RepositoryScoreLicence
This page · wiolett-industries/marketplace90MIT
nikospavlopoulos/devops-mutant-powers100MIT
arklab/ark.tools100MIT
arklab/ark.tools100MIT
ongtungduong/legion100MIT
osmontero/opencode-skills100MIT
GanyuanRan/Aegis100MIT
seaworld008/commonly-used-high-value-skills100MIT
FrancoStino/opencode-skills-collection100MIT

Database snapshot: 13.11.2026 · package version fa027731f51f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100execute-plan
    Execute structured task plans with status tracking. Use when the user provides a plan file path in the format `plans/{current-date}-{task-name}-{version}.md` or explicitly asks you to execute a plan file.
  • 90sr-executing-plans
    Use when you have a written implementation plan to execute in a separate session with review checkpoints
  • 100implement-plan
    Execute an approved implementation plan from the configured plans directory. Use when the user wants to implement a plan phase by phase with verification.
  • 90evanflow-executing-plans
    Execute a written implementation plan task-by-task with inline verification. Stop and ask on blockers. No forced sub-skill chains. Use when a plan exists and you're ready to implement.
  • 100execute
    Execute an approved implementation plan from .ai/plans/ task by task, running each task's verification and committing per task via the check-and-commit gate. Use when asked to "execute the plan", "implement the plan", or after /plan approval. Do not use without an approved plan…
  • 100review-plan
    Use after writing implementation plans (superpowers:writing-plans output) or when the user says "review plan", "check my plan", "sanity check the plan", "validate plan", "review before executing". Also use before superpowers:executing-plans if a plan has not been reviewed yet.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.