home / skills / nickcrew / claude-cortex / executing-plans

executing-plans skill

safe

This skill locks in the plan and drives its execution through cortex orchestration and verification, turning strategy into tracked tasks and progress.

npx playbooks add skill nickcrew/claude-cortex --skill executing-plans

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

1.5 KB

---
name: executing-plans
description: Execution discipline skill adapted from obra/superpowers. Ensures plans translate into tracked tasks, orchestration, and verification runs.
license: MIT (obra/superpowers)
---

# `/collaboration:executing-plans`

Locks in the plan and drives it through cortex’s orchestration + verification stack.

## Prereqs

- `/ctx:plan` output in the thread.
- Tasks captured in the Task view (`T`) or ready to be created now.
- Relevant modes/agents activated.

## Steps

1. **Create/Sync Tasks**
   - For each plan item, add/edit a task (Task view `T` → `A`/`E`).
   - Ensure category + workstream mirror the plan’s stream names.
2. **Activate Modes & Rules**
   - Toggle required modes (`3` view) and rules (`4` view) to match plan.
3. **Run Workstream Loops**
   - Pick a task → do the work → update status/progress.
   - Use `/ctx:verify` rules (tests, lint, Supersaiyan visual check) before moving to next task.
4. **Update Stakeholders**
   - For finished streams, summarize progress + next up; attach screenshots/logs when relevant.
5. **Retrospective Hooks**
   - When all tasks complete, close them in Task view, capture learnings in chat, and link to plan doc.

## Output

- Tasks JSON updated under `tasks/current/active_agents.json`.
- Status update message covering completed tasks, blockers, verification evidence.
- Next steps or follow-up issues if needed.

## Resources

- Execution checklist: `skills/collaboration/executing-plans/resources/checklist.md`.

Overview

This skill ensures written plans become tracked, verifiable work by locking a plan into task flows, running orchestration loops, and collecting verification evidence. It integrates task creation, mode activation, and verification checks to drive steady progress and clear handoffs. The result is synchronized task state, status updates, and an auditable trail of verification artifacts.

How this skill works

The skill inspects the current plan context and creates or syncs tasks so each plan item maps to a task with matching category and workstream. It activates required modes and rules, guides repeated workstream loops (do work → run verification → update status), and produces status messages plus verification artifacts. When all tasks finish, it triggers retrospective capture and creates follow-up issues as needed.

When to use it

After a plan has been finalized and is present in the plan context
When you need disciplined execution with tracked tasks and verification evidence
Before handing work off to stakeholders who require progress summaries and artifacts
When multiple agents or modes must be coordinated across workstreams
When you need an audit trail of verification runs and closure notes

Best practices

Ensure the plan is present in the thread as the active plan context before starting
Create or edit tasks to mirror the plan’s stream names, categories, and priorities
Toggle modes and rules to reflect the plan (automation, linting, visual checks) before running loops
Run verification rules (tests, lint, visual checks) on each task before marking it complete
Attach logs, screenshots, and verification output to status updates for stakeholder clarity
Capture retrospectives and lessons learned when all tasks are closed and link them back to the plan

Example use cases

Turning a high-level roadmap into tracked tasks with verification for a sprint kickoff
Coordinating multiple agents to implement a feature and collecting test/lint evidence before release
Running a cross-team workstream where modes (automation, CI checks) must be toggled per task
Producing a stakeholder-ready status update summarizing completed streams, blockers, and attached verification artifacts
Closing a project cycle, capturing retrospectives, and creating follow-up issues for improvements

FAQ

What input does this skill require?

It requires the active plan context in the thread and tasks either ready to be created or present in the Task view.

What does the skill produce as output?

Updated tasks JSON for active agents, a status update message with completed tasks and verification evidence, and any next-step or follow-up issues.