Skip to content
Skills Library
AI & agents · Automation

execute

/execute

Runs a wipnote plan or track by dependency-driven parallel dispatch: partitions non-conflicting slices, keeps every spawned agent attributed, and closes them all. Use when asked to execute, run or implement a plan or track.

Repository
htmlgraph ↗
Licence
MIT
Last repository change
27.10.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.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

Runs a wipnote plan or track by dependency-driven parallel dispatch: partitions non-conflicting slices, keeps every spawned agent attributed, and closes them all. Use when asked to execute, run or implement a plan or track.

Original author description

Runs a wipnote plan or track by dependency-driven parallel dispatch: partitions non-conflicting slices, keeps every spawned agent attributed, and closes them all. Use when asked to execute, run or implement a plan or track.

How it works

  1. Environment
  2. Efficiency Rules
  3. Work Item Attribution
  4. Core Loop
  5. Step 1: Find Ready Work
  6. Step 2: Check File Overlap
  7. Step 3: Spawn Agents
  8. Step 4: Track Running Agents
  9. Step 5: Wait and Unblock
  10. Step 6: Merge and Verify
Original SKILL.md headings · 183 lines, 1,078 words
SKILL.md preview
---
name: execute
description: "Runs a wipnote plan or track by dependency-driven parallel dispatch: partitions non-conflicting slices, keeps every spawned agent attributed, and closes them all. Use when asked to execute, run or implement a plan or track."
---

# wipnote Parallel Execute

Use this skill to execute development work in parallel with dependency-driven dispatch and isolated agents.

Copy this checklist and tick it off:

```
Execute (<track or plan id>):
- [ ] 1. Ready work found (Step 1)
- [ ] 2. File overlap checked; non-conflicting set chosen (Step 2)
- [ ] 3. Agents spawned and tracked (Steps 3–4)
- [ ] 4. Agents waited on; blockers unblocked (Step 5)
- [ ] 5. Merged; tests and checks pass (Step 6)
- [ ] 6. Steps 1–5 repeated until done (Step 7)
- [ ] 7. Completion checklist (end of this file) all ticked
```

## Environment

When running in a worktree, `WIPNOTE_PROJECT_DIR` is set automatically. All `wipnote` CLI commands resolve to the main project's `.wipnote/`. Run commands directly unless a tool explicitly needs a different directory.

## Efficiency Rules

Every tool call spends a turn. Aim to dispatch the first subagent quickly.

1. Use `wipnote execute-preview <trk-id> --format json` as the main discovery call.
2. Reuse that payload instead of re-querying the same track or feature data repeatedly.
3. Batch related `wipnote` probes when you need extra state.
4. Let readiness and file overlap decide dispatch order; do not build a manual wave plan first.

## Work Item Attribution

Before dispatching agents:

1. Run `wipnote status` and confirm the active feature, bug, or track.
2. If the target work item is not active, start it first.
3. Every spawned agent prompt must include:
   - `wipnote feature start <feat-id>` or `wipnote bug start <bug-id>` as the first command
   - completion of the same work item after quality gates pass

Without attribution, the execution graph stays incomplete.

## Core Loop

Run a dispatch loop driven by readiness, not by manual waves:

1. Identify ready work: pending items with no unresolved dependencies.
2. Check file overlap among ready candidates.
3. Spawn all non-conflicting ready tasks in parallel.
4. Wait for each spawned agent to finish.
5. Review results, merge the completed work, and run quality gates.
6. Recompute readiness and repeat until no work remains.

If only one ready task remains, use the same loop; the parallel step just has one agent.

## Step 1: Find Ready Work

Use the preview payload as the source of truth.

Treat linked features or bugs with pending status and no blockers as ready candidates. Keep blocked items out of the current dispatch set. Reuse the track title when describing the overall execution session.

If the track does not yet have executable work items, stop and create or promote them first. Attribute work to the `feat-…` id that `wipnote plan promote-slice` creates, never the plan's `slice-N` id.

## Step 2: Check File Overlap

Before parallel dispatch, compare the file sets for ready candidates.

For each candidate:

1. Run `wipnote trace <work-item-id>` to inspect attributed files.
2. Compute pairwise overlap.
3. Partition ready work into the largest non-conflicting set you can safely run together.

Rules:

- No overlap: dispatch every ready candidate now.
- Partial overlap: dispatch the non-conflicting subset first and defer the conflict to the next loop.
- Full overlap: dispatch one candidate, note the constraint, and continue after merge.

Dependency independence is not enough if two agents will both edit the same file.

## Step 3: Spawn Agents

Use Codex lifecycle primitives directly.

For each chosen task, call `spawn_agent` with:

- the appropriate agent type
- a concise description
- the full task prompt, including attribution and test expectations

Example structure:

```text
spawn_agent(
  agent_type="wipnote-feature-coder",
  description="feat-1234: Add execute preview cache",
  message="""
Feature: feat-1234

FIRST command: wipnote feature start feat-1234

Goal: implement the slice described below.
Files to edit: internal/foo.go, internal/foo_test.go
Requirements:
- write or update focused tests
- run relevant quality gates
- complete the feature when passing
Report changed files and tests run.
"""
)
```

Use `wipnote-patch-coder` for tiny, tightly scoped edits and `wipnote-feature-coder` for ordinary feature slices unless the plan clearly calls for another role.

## Step 4: Track Running Agents

Immediately record the handles returned by `spawn_agent`.

Maintain a live table in your notes with the work item id, agent handle, intended files, and dispatch time.

Codex has no Task tools, so record progress on the work item itself: `wipnote feature add-step <feat-id> "<step>"` for each dispatched slice, and `wipnote feature complete-step <feat-id> <step-number>` once it is merged and its gate passes. This keeps the execution state resumable after a crash.

## Step 5: Wait and Unblock

Use the lifecycle primitives in this order:

1. `wait_agent` for a spawned handle until it yields a result or needs input.
2. If the agent asks for clarification and you can answer from existing context, use `send_input`.
3. When an agent is done and no further interaction is needed, `close_agent` its handle.

Guidelines:

- Prefer concrete file or requirement context when answering.
- If an agent is stuck on a failing test or merge conflict, resolve whether to clarify, defer, or reroute before spawning more overlapping work.
- Close idle handles promptly so the execution state stays clean.

## Step 6: Merge and Verify

After an agent completes:

1. Inspect its summary and changed files.
2. Merge or apply the completed work.
3. Run the relevant quality gates for the touched surface.
4. Only then mark the work item complete.

If quality gates fail, reopen the loop with a narrower follow-up task instead of carrying broken state forward.

## Step 7: Repeat Until Done

After each successful merge:

1. Refresh readiness from `wipnote execute-preview <trk-id> --format json`.
2. Re-run the file overlap check on the newly ready set.
3. Spawn the next non-conflicting batch.

Stop when there are no pending ready items and all blocked items have either completed dependencies or been explicitly deferred.

## Failure Handling

When a spawned agent fails:

1. capture the failure summary
2. decide whether a short `send_input` can unblock it
3. if not, `close_agent` the failed handle
4. create or queue a narrower follow-up task before retrying

Do not leave abandoned agent handles hanging around after a failed wave.

## Completion Checklist

Before you declare execution finished, every item must be ticked:

```
- [ ] Every spawned agent has been waited on
- [ ] Needed clarifications were sent with `send_input`
- [ ] Completed handles were closed with `close_agent`
- [ ] Merged changes passed relevant tests and checks
- [ ] Work items were completed in `wipnote`
- [ ] Remaining blocked or deferred work is called out
```

Versions

RepositoryScoreLicence
This page · shakestzd/htmlgraph100MIT
insideout-ai/make-it-work100MIT
yaleh/quay100MIT
jkaloger/lazyspec100MIT
shakestzd/htmlgraph100MIT
shakestzd/htmlgraph100MIT
crbnos/carbon100AGPL-3.0
alirezarezvani/claude-skills100MIT
gridconsole/grid-plugins100MIT

Database snapshot: 13.11.2026 · package version e7652959ed8e (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

  • 100parallel-orchestrator
    Orchestrate parallel agent workflows using Wipnote's ParallelWorkflow. Activate when planning multi-agent work, using Task tool for sub-agents, or coordinating concurrent feature implementation.
  • 81skills
    Lists every wipnote skill, including those hidden from the skill list (planning, plan critique, UI checks, guard profiles, issue reports), and how to load each one. Use to find the right wipnote workflow before starting one.
  • 100orchestrate
    Drives full multi-agent implementation from a blueprint — fans out parallel-safe tasks into waves, runs sequential tasks in order, resolves conflicts, then verifies. Use to execute an approved plan.
  • 84implement-dispatch
    Orchestrated execution of an approved plan or a spec'd work-item list through worker subagents: scope-fenced briefs, capped waves, returns verified against direct evidence, and the build run main-side instead of inline edits. Use when the plan routes phases to worker surfaces,…
  • 90do
    Execute a phased implementation plan using subagents. Use when asked to execute, run, or carry out a plan — especially one created by make-plan.
  • 95plan-orchestrate
    Execute implementation plans with parallel TDD workers. Use when ready to run, execute, or start a plan. Triggers on "run the plan", "execute the plan", "implement the plan", "start the plan", "start implementation", "orchestrate", "begin autonomous execution". Requires a plan…

Feedback and reports

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