plan-and-execute
Skill8 starsChanged 4 days agoMITView on GitHub
General-purpose orchestrator for challenge → plan → stress-test → phased execution. Produces a plan, stress-tests it, then enrolls each phase as an autonomous TODO with deliverables, success criteria, and built-in quality gates. Between phases, runs structured retrospectives that drive improvements into all upcoming TODOs.
1 other project uses a version of this.
Adopted by
Most recently taken up by
- GrowingGold/super-skills-kittheir own version, first seen Nov 16, 2026
Other versions1 project uses a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 1
- GrowingGold/super-skills-kit★ 1same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository134 other files it gives its agents.
- AGENTS.mdAGENTS.md
- guidance/AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- guidance/CLAUDE.mdCLAUDE.md
- .github/copilot-instructions.mdCopilot instructions
- .cursor/rules/cli-tools.mdcCursor rule
- .cursor/rules/invariants.mdcCursor rule
- .cursor/rules/javascript.mdcCursor rule
- .cursor/rules/security.mdcCursor rule
- .cursor/rules/shell.mdcCursor rule
- blast-radius-checkSkill
- brainstormingSkill
- branch-flow-gateSkill
- branch-sync-gateSkill
- codebase-reconSkill
- codeowners-drift-auditSkill
- code-review-batterySkill
- cognitive-complexity-refactoringSkill
- debateSkill
- debug-conductorSkill
- dispatching-parallel-agentsSkill
- domain-buildSkill
- evidence-adjudicatorSkill
- executing-plansSkill
- external-cli-auditSkill
- feature-developmentSkill
- field-rename-verificationSkill
- finishing-a-development-branchSkill
- git-branch-conventionsSkill
- gitlab-cliSkill
- hotfix-charterSkill
- implementation-trackerSkill
- incident-revert-reviewSkill
- infra-config-investigatorSkill
- investigation-stateSkill
- kernel-splitSkill
- llm-behavior-investigatorSkill
- llm-skill-reviewSkill
- merge-authorization-gateSkill
- micro-harsh-reviewSkill
- output-verificationSkill
- pre-commit-gateSkill
- progressive-code-review-gateSkill
- progressive-harsh-reviewSkill
- providing-code-reviewSkill
- pr-triage-gateSkill
- push-authorization-gateSkill
- receiving-code-reviewSkill
- reproduction-experiment-investigatorSkill
- requesting-code-reviewSkill
- requirements-validation-pmSkill
- requirements-validationSkill
- scope-tripwireSkill
- session-handoffSkill
- skills-hierarchy-tuningSkill
- sp-bughuntSkill
- state-consistency-investigatorSkill
- subagent-driven-developmentSkill
- systematic-debuggingSkill
- test-driven-developmentSkill
- The first 60 shown.
The file
Show its rules and text
We split this skill into the rules it gives an agent
14 rules. About 0 are common, 10 are distinctive, and 4 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈10
Distinctive · estimate
This author's own choices. Worth a look.
4
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 46
Run use-skill unified-commit-gate before committing
- Distinctive: line 47
Verify the deliverables match the stated goal
- Distinctive: line 57
If any auto-escalate signal fires, continue reading the full skill below.
- Very specific: line 63
Use
feature-developmentinstead: when the work is a code feature needing requirements validation or a design debate (≥3 options). - Very specific: line 80
Ask clarifying questions one at a time (like brainstorming)
- Distinctive: line 113
Run minimum 2 rounds of stress-testing.
- Distinctive: line 134
Exit gate: All phases enrolled in TODO.md with full context.
- Distinctive: line 163
Add guards against failure modes we discovered
- Distinctive: line 167
Harsh-review rewritten TODOs: before finalizing (are the improvements real?
- Distinctive: line 177
Verify success criteria are met
- Distinctive: line 207
If a retrospective or harsh review reveals the remaining plan is fundamentally wrong (not just needs tweaking):
- Distinctive: line 219
If a project was started in a previous session:
- Very specific: line 220
Check TODO.md for #plan-<project> items via todo-crud.sh list
- Distinctive: line 222
Run a retrospective on the completed phase
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Plan and Execute
Purpose: Turn any challenge into a stress-tested, phased plan — then execute each phase as an autonomous TODO with built-in quality gates and continuous improvement between phases. Pattern: This skill ORCHESTRATES existing skills. It does not replace them.
Announce at start: "I'm using the plan-and-execute skill to orchestrate this work."
Quick Mode (Simple Features)
For single-phase work with clear scope (bug fix, small feature, config update, single-file edit) — use this lightweight path instead of the full phased procedure below.
Note: This skill's anti_triggers suppress it for "small change", "quick fix", etc. Quick Mode is for cases where you're already inside plan-and-execute (triggered by a broader planning phrase) and scope turns out to be simple — OR where you load this skill explicitly for its Quick Mode path.
- State the goal in one sentence
- List files to create or modify
- Execute the work
- Run
use-skill unified-commit-gatebefore committing - Verify the deliverables match the stated goal
When MCP add_tasks is available, use it directly for task tracking — do NOT also load todo-management.
Auto-escalate to the full procedure below if any of these appear during execution:
- 3+ subtasks emerge that weren't visible at the start
- External dependency or blocked work discovered
- Scope changes from the user mid-work
- Work spans multiple repos, services, or teams
If any auto-escalate signal fires, continue reading the full skill below.
When to Use / Not Use
Use: Multi-phase challenge (code, process, research, docs, design) where planning before execution reduces risk.
Skip: Single-step tasks (just do them). Pure bug fixes → investigation-state. Plan already enrolled in TODO.md → todo-management to resume.
Use feature-development instead when the work is a code feature needing requirements validation or a design debate (≥3 options).
The Workflow
Phase A: CHALLENGE INTAKE → Phase B: PLAN → Phase C: STRESS-TEST →
Phase D: PHASE ENROLLMENT → Phase E: EXECUTE (retro → improve → do → review)Phase A: Challenge Intake
- Receive the challenge from the user
- Clarify scope, constraints, and success criteria
- Ask clarifying questions one at a time (like
brainstorming) - OR accept an autonomous mandate — either mode works
- Ask clarifying questions one at a time (like
- Restate the challenge back to confirm understanding
- Exit gate: User confirms the challenge statement is accurate
Phase B: Devise the Plan
- Produce a plan that addresses the challenge
- Interactive co-development OR autonomous drafting — match user's mode
- Structure the plan as ordered phases with dependency relationships
- Each phase must state: purpose, deliverables, and exit criteria
- Apply
plan-quality-gates: no fabricated timelines, dependency ordering, verifiable exit criteria - Exit gate: Plan exists with phases, dependencies, and exit criteria
Phase C: Stress-Test the Plan
This phase is critical. Plans almost always have significant problems that surface here.
Apply whichever combination of these tools makes sense to pressure-test the plan:
- Brainstorming — Are there better approaches we haven't considered? Alternative phasing? Missing phases?
- Think-twice — Dispatch a fresh sub-agent with zero context to review the plan. What did we miss?
- Harsh review — Red-team the plan by answering these questions:
- What's the weakest phase?
- What dependency is wrong or missing?
- What will fail first?
- What assumption is untested?
- What edge case breaks the whole plan?
Run minimum 2 rounds of stress-testing. Fix issues found, then re-review.
If stress-testing reveals the plan is fundamentally broken (the approach itself is wrong, not just needs tweaks — e.g., wrong decomposition, missing a critical phase, flawed sequencing), return to Phase B and replan. State clearly: "The plan needs to be reworked, not refined."
- Exit gate: Plan has survived stress-testing. All issues that would change execution are resolved. User approves the final plan.
Phase D: Phase Enrollment
- Name the project — ask user for a project tag or generate one (kebab-case). Example:
#plan-auth-redesign - Enroll each phase as an autonomous TODO via
todo-crud.sh. "Autonomous" means: a fresh agent with no conversation history could pick up this TODO and execute it successfully. Each TODO must include:- Purpose: WHY this phase exists
- Trinity: WHY / WHAT / HOW (with file paths, commands, concrete references — not vague gestures)
- Deliverables: Concrete outputs (files, states, artifacts)
- Success Criteria: Binary done/not-done, verifiable by command or inspection
- Quality Gate: "Run progressive harsh review on deliverables before marking complete"
- Handoff State: What the next phase needs to know (branch, last commit, partial work, gotchas)
- Tag all TODOs with
#plan-<project-name> - Order by dependency (not calendar)
- Mirror to MCP task list via
add_taskswith parent/child structure - Exit gate: All phases enrolled in TODO.md with full context. User confirms.
Phase E: Execute (The Loop)
For each phase TODO, in order:
Step 1: Pre-Phase Retrospective
Skip for the first phase. For all subsequent phases:
Load references/retrospective-template.md and complete:
- What went well in the last phase (keep doing)
- What didn't go well (stop or change)
- What did progressive harsh review surface that we didn't anticipate?
- Process improvement — one concrete change to how we work
- Quality improvement — one concrete change to what we check
Persistence: Summarize the retro's key findings (what changed, why) as a completion note via todo-crud.sh complete --note "Retro: [1-3 sentence summary of findings and changes made to upcoming TODOs]". The full retro is in conversation context; the note captures enough for cross-session resumption.
Step 2: Improve Upcoming TODOs
Review EVERY remaining TODO in the #plan-<project> list:
- Apply learnings from the retrospective
- Drive at minimum 2 substantive improvements across all remaining TODOs (not 2 per TODO — distribute where they add real value). If a TODO genuinely needs no changes, state why and move on. Forced improvements become filler.
- Sharpen success criteria based on what we learned
- Add guards against failure modes we discovered
- Improve the HOW based on what worked/didn't
- Strengthen the quality gate based on harsh review findings
- Rewrite affected TODOs via
todo-crud.shwith improvements - Harsh-review rewritten TODOs before finalizing (are the improvements real? do they conflict with other phases?)
Scaling note: For projects with many remaining phases, focus improvement effort on the next 2-3 phases (highest impact). Scan later phases for applicability but don't force changes into distant phases that may themselves change.
Step 3: Execute the Phase
- Re-read the TODO (it may have been improved by a prior retro)
- Execute the work described in the TODO
- Before any
git commitduring this phase: invokeunified-commit-gate(all applicable gates). Do not skip because the plan is mid-flight. - Harsh-review all deliverables (same red-team questions as Phase C, applied to outputs not plans)
- Verify success criteria are met
- Mark TODO complete via
todo-crud.shwith completion notes
If the phase fails (deliverables don't meet criteria, blockers surface, harsh review finds critical issues): document what went wrong in the TODO note, run a retrospective immediately, and decide whether to retry the phase or trigger mid-execution replanning.
Step 4: Post-Phase Verification
- Confirm deliverables exist and meet success criteria
- Confirm handoff state is documented for the next phase
- Before pushing the branch (once per push, not per phase): invoke
unified-commit-gatevia/sp-push. A valid.code-review-clearedsentinel must exist for HEAD; if missing, runcode-review-batteryfirst. - Exit gate: TODO marked complete, deliverables verified, handoff state captured
Phase Skip Prevention
You MUST NOT skip phases. The stress-test phase (C) is where most value is created.
| Temptation | Why It Fails |
| "The plan is obvious" | Obvious plans have unexamined assumptions |
| "Stress-testing is overkill" | Plans almost always have significant problems found here |
| "Retrospectives slow us down" | They systematically improve every subsequent phase |
| "The TODOs are fine as-is" | Pre-execution improvement is the whole point |
| "Just one round of review" | Minimum 2 rounds. First round finds surface issues; second finds structural ones |
Mid-Execution Replanning
If a retrospective or harsh review reveals the remaining plan is fundamentally wrong (not just needs tweaking):
- State clearly: "The plan needs replanning from Phase N onward."
- Defer remaining TODOs via
todo-crud.sh defer --reason "Replanning triggered" - Return to Phase B (Plan) with the new understanding — the completed phases and their retros are inputs
- Re-run Phase C (Stress-Test) on the revised plan
- Re-enroll via Phase D — new TODOs replace the deferred ones
This is NOT failure — it's the system working as designed. Continuing with a broken plan is the failure.
Resuming a Project
If a project was started in a previous session:
- Check TODO.md for
#plan-<project>items viatodo-crud.sh list - Identify the last completed phase
- Run a retrospective on the completed phase
- Improve remaining TODOs
- Resume execution from the next incomplete phase
Integration Map
| Phase | Skills Invoked | Purpose |
| Challenge Intake | (conversational) | Clarify scope and constraints |
| Plan | plan-quality-gates | Dependency ordering, exit criteria |
| Stress-Test | brainstorming, think-twice, harsh review (red-team questions) | Pressure-test the plan |
| Enrollment | todo-management | Persistent, autonomous TODOs |
| Execute | harsh review on deliverables; unified-commit-gate MANDATORY before any commit/push (sentinel required for code changes); final review delegated to execution skill (requesting-code-review or finishing-a-development-branch) | Quality at every step |
| Replan | (back to Plan + Stress-Test if fundamentally broken) | Course correction |
Failure Modes
| Failure | Fix |
| Stress-test phase skipped, plan fails during execution | Phase C is mandatory — minimum 2 review rounds |
| Retrospectives are shallow ("everything was fine") | Template requires concrete findings and changes |
| TODO improvements are cosmetic | "Substantive" means changes that would alter execution, not wording tweaks |
| Harsh review on deliverables is skipped | Quality gate is embedded in every TODO — it's not optional |
| Upcoming TODOs not actually rewritten | Changes must be persisted via todo-crud.sh, not just noted |
| Plan is broken but execution continues | Use mid-execution replanning — defer remaining TODOs, return to Phase B |
| Improvements forced into every TODO as filler | Distribute improvements where they add value; skip with justification |
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

