Skip to content
Skills Library
AI & agents · Automation

executing-plans

/executing-plans

Execution discipline that translates plans into tracked tasks with orchestration and verification loops. Use when driving a plan through cortex’s task system, coordinating workstreams across agents, or ensuring every plan item is tracked, executed, and verified.

Licence
MIT
Last repository change
28.06.2026

Assessment and security

100/ 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.
Content35 / 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 28.06.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

Execution discipline that translates plans into tracked tasks with orchestration and verification loops. Use when driving a plan through cortex’s task system, coordinating workstreams across agents, or ensuring every plan item is tracked, executed, and verified.

Original author description

Execution discipline that translates plans into tracked tasks with orchestration and verification loops. Use when driving a plan through cortex’s task system, coordinating workstreams across agents, or ensuring every plan item is tracked, executed, and verified.

How it works

  1. When to Use This Skill
  2. Prerequisites
  3. Workflow
  4. Expected Output
  5. Best Practices
  6. Resources
Original SKILL.md headings · 92 lines, 502 words
SKILL.md preview
---
name: executing-plans
description: Execution discipline that translates plans into tracked tasks with orchestration and verification loops. Use when driving a plan through cortex’s task system, coordinating workstreams across agents, or ensuring every plan item is tracked, executed, and verified.
keywords:
  - execute plan
  - follow plan
  - start implementing
file_patterns:
  - '**/TODO.md'
  - '**/docs/plans/**'
  - '**/notes/**'
  - '**/planning/**'
  - '**/scenarios/**'
  - '**/todo.md'
confidence: 0.82
license: MIT (obra/superpowers)
tags:
  - collaboration
  - execution
  - task-management
  - orchestration
---

# Executing Plans

Locks in an approved plan and drives it through cortex’s orchestration and verification stack, ensuring every item becomes a tracked task that is executed, verified, and reported.

## When to Use This Skill

- A plan from `writing-plans` or `/ctx:plan` is ready for execution
- Coordinating multiple workstreams or agents against a shared plan
- Ensuring plan items are tracked as tasks with status updates
- Running verification loops (tests, lint, visual checks) before marking tasks done
- Avoid using before a plan exists — use `writing-plans` first

## Prerequisites

- Plan output available in the thread (from `writing-plans` or `/ctx:plan`)
- Access to Task view (`T`) in cortex TUI
- Relevant modes and agents activated for the workstreams

## Workflow

### Step 1: Create and Sync Tasks

For each plan item, create or update a task in the Task view:

```
Task view (T) → Add (A) or Edit (E)
```

- Set **category** and **workstream** to mirror the plan’s stream names
- Ensure every plan item has a corresponding task — no orphan items
- Link tasks to the originating plan document

### Step 2: Activate Modes and Rules

Toggle the required configuration to match the plan:

- **Modes** (view `3`): Activate modes needed for current workstreams
- **Rules** (view `4`): Enable rules that apply (e.g., testing requirements, style enforcement)

### Step 3: Execute Workstream Loops

For each task in priority order:

1. **Pick** the next task from the active workstream
2. **Execute** the work (implementation, writing, configuration, etc.)
3. **Verify** before marking complete:
   - Run tests: `pytest`, `vitest`, or project-specific test command
   - Run linting: `just lint` or equivalent
   - Visual check via Supersaiyan if UI changes are involved
4. **Update** task status and progress notes

```bash
# Example verification sequence
just test && just lint && echo "Verification passed"
```

### Step 4: Update Stakeholders

For each completed workstream:

- Summarize progress and what’s next
- Attach relevant screenshots, logs, or test output
- Flag any blockers or scope changes discovered during execution

### Step 5: Run Retrospective Hooks

When all tasks are complete:

1. Close all tasks in the Task view
2. Capture learnings and surprises in the chat thread
3. Link back to the original plan document
4. Note any follow-up issues or tech debt discovered

## Expected Output

- `tasks/current/active_agents.json` updated with task statuses
- Status update message covering: completed tasks, blockers, verification evidence
- Next steps or follow-up issues if the plan extends beyond this session

## Best Practices

- **Verify before advancing** — Never mark a task done without running the verification loop
- **One task at a time** — Complete and verify each task before starting the next
- **Update status in real time** — Stakeholders should see progress, not just a final dump
- **Link everything** — Tasks link to plan, plan links to tasks, status updates reference both
- **Capture blockers immediately** — Don’t wait until the retrospective to surface problems

## Resources

- Execution checklist: `skills/collaboration/executing-plans/resources/checklist.md`
Files in this package (2)
  • SKILL.md 4 KB
  • resources/checklist.md 1 KB

Versions

RepositoryScoreLicence
This page · NickCrew/Claude-Cortex100MIT
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 4bc9a6b7ee2b (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

  • 100cortex-run
    ONLY load this skill when the user explicitly types $cortex-run or /cortex-run. NEVER load this skill from auto-routing hooks or keyword matching. For auto-routed prompts, use snowflake-cortex-code:cortex-router instead.
  • 100doing-tasks
    Use when executing any task. Work through plans systematically, tracking progress, handling blockers, and coordinating with other skills. The central execution skill.
  • 100cortex-evolve
    Save knowledge to the cortex vault. Use when the user says "存到 cortex", "記一下", "save to cortex", "記到筆記", "cortex evolve", or when the session-suggest hook recommends saving content. Handles Notes and Projects.
  • 100cortex-setup-project
    Bootstrap Cortex for a new project or import existing session history. Use when the user says 'set up Cortex', 'seed this project', 'import my history', 'backfill memories', 'bootstrap memory', 'initialize Cortex for this project', or when starting to use Cortex on an existing…
  • 100cortex-skills-loop
    Drives the cortex skills recommend-feedback-rate loop. Use when a context change occurs (new file types, domain shift, task pivot) or when a task completes and skill effectiveness should be recorded.
  • 100plan-orchestration
    Plan execution through coordinated subagents - delegation, review, verification, integration. Use when executing an existing plan via subagents, including resuming interrupted orchestration. Not for inline execution (plan-execution) or unrelated parallel investigations.

Feedback and reports

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