Agent skill

Delegated Execution

by NoobyGains in NoobyGains/godmode

A skill your agent uses when executing implementation plans with independent tasks in the current session

MITAuto-check passedAgent Workflows

Install Delegated Execution

skills CLI
$ npx skills add NoobyGains/godmode --skill delegated-execution -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install NoobyGains/godmode delegated-execution --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/NoobyGains/godmode.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/delegated-execution .claude/skills/delegated-execution && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
delegated-execution
GitHub stars
107
Token cost
~2.4k tokens
SKILL.md length
447 words
Files
4
Skills in repo
34
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when executing implementation plans with independent tasks in the current session

  • Executing implementation plans with independent tasks in the current session
  • SKILL.md covers When to Use, The Process, Prompt Templates and Example Workflow, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Tasks that involve Planning

What it does

Delegated Execution is an agent skill from NoobyGains/godmode. Use when executing implementation plans with independent tasks in the current session

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files (for example `code-quality-reviewer-prompt.md`, `implementer-prompt.md` and `spec-reviewer-prompt.md`).

It sits in Agent Workflows, covering Planning. The repository describes itself as: The AI development framework that thinks before it builds. 36 composable skills for Claude Code, Cursor, Codex, and OpenCode. The licence is MIT.

When your agent uses it

  • Executing implementation plans with independent tasks in the current session
  • Tasks that involve Planning

Example prompts

  • “/delegated-execution”

What it can do on your machine

Read from SKILL.md and the folder at commit 441103a. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are dot).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Delegated Execution loads about 2.4k tokens when it runs. Until then it costs about 26 tokens; SKILL.md has 447 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~26
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from NoobyGains/godmode at commit 441103a, republished under its MIT licence (© NoobyGains). 447 words, ~2,407 tokens.

Download SKILL.mdSave it as .claude/skills/delegated-execution/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
delegated-execution
description
Use when executing implementation plans with independent tasks in the current session

Delegated Execution

Execute a plan by dispatching a fresh subagent per task, with two-stage review after each: specification compliance first, then code quality.

Core principle: Fresh subagent per task + two-stage review (spec then quality) = high quality, fast iteration

When to Use

dot
digraph applicability {
    "Implementation plan exists?" [shape=diamond];
    "Tasks mostly independent?" [shape=diamond];
    "Stay in current session?" [shape=diamond];
    "delegated-execution" [shape=box];
    "task-runner" [shape=box];
    "Manual execution or go back to intent-discovery" [shape=box];

    "Implementation plan exists?" -> "Tasks mostly independent?" [label="yes"];
    "Implementation plan exists?" -> "Manual execution or go back to intent-discovery" [label="no"];
    "Tasks mostly independent?" -> "Stay in current session?" [label="yes"];
    "Tasks mostly independent?" -> "Manual execution or go back to intent-discovery" [label="no - tightly coupled"];
    "Stay in current session?" -> "delegated-execution" [label="yes"];
    "Stay in current session?" -> "task-runner" [label="no - separate session"];
}

vs. Task Runner (separate session):

  • Same session (no context switch)
  • Fresh subagent per task (no context contamination)
  • Two-stage review after each task: spec compliance first, then code quality
  • Faster iteration (no human-in-loop between tasks)

The Process

dot
digraph workflow {
    rankdir=TB;

    subgraph cluster_per_task {
        label="Per Task";
        "Dispatch builder subagent (./implementer-prompt.md)" [shape=box];
        "Builder subagent has questions?" [shape=diamond];
        "Answer questions, supply context" [shape=box];
        "Builder subagent implements, tests, commits, self-reviews" [shape=box];
        "Dispatch spec auditor subagent (./spec-reviewer-prompt.md)" [shape=box];
        "Spec auditor confirms code matches spec?" [shape=diamond];
        "Builder subagent fixes spec gaps" [shape=box];
        "Dispatch quality auditor subagent (./code-quality-reviewer-prompt.md)" [shape=box];
        "Quality auditor approves?" [shape=diamond];
        "Builder subagent fixes quality issues" [shape=box];
        "Mark task complete in plan checklist" [shape=box];
    }

    "Read plan, extract all tasks with full text, note context, build task checklist" [shape=box];
    "More tasks remaining?" [shape=diamond];
    "Dispatch final quality auditor for entire implementation" [shape=box];
    "Use godmode:merge-protocol" [shape=box style=filled fillcolor=lightgreen];

    "Read plan, extract all tasks with full text, note context, build task checklist" -> "Dispatch builder subagent (./implementer-prompt.md)";
    "Dispatch builder subagent (./implementer-prompt.md)" -> "Builder subagent has questions?";
    "Builder subagent has questions?" -> "Answer questions, supply context" [label="yes"];
    "Answer questions, supply context" -> "Dispatch builder subagent (./implementer-prompt.md)";
    "Builder subagent has questions?" -> "Builder subagent implements, tests, commits, self-reviews" [label="no"];
    "Builder subagent implements, tests, commits, self-reviews" -> "Dispatch spec auditor subagent (./spec-reviewer-prompt.md)";
    "Dispatch spec auditor subagent (./spec-reviewer-prompt.md)" -> "Spec auditor confirms code matches spec?";
    "Spec auditor confirms code matches spec?" -> "Builder subagent fixes spec gaps" [label="no"];
    "Builder subagent fixes spec gaps" -> "Dispatch spec auditor subagent (./spec-reviewer-prompt.md)" [label="re-audit"];
    "Spec auditor confirms code matches spec?" -> "Dispatch quality auditor subagent (./code-quality-reviewer-prompt.md)" [label="yes"];
    "Dispatch quality auditor subagent (./code-quality-reviewer-prompt.md)" -> "Quality auditor approves?";
    "Quality auditor approves?" -> "Builder subagent fixes quality issues" [label="no"];
    "Builder subagent fixes quality issues" -> "Dispatch quality auditor subagent (./code-quality-reviewer-prompt.md)" [label="re-audit"];
    "Quality auditor approves?" -> "Mark task complete in plan checklist" [label="yes"];
    "Mark task complete in plan checklist" -> "More tasks remaining?";
    "More tasks remaining?" -> "Dispatch builder subagent (./implementer-prompt.md)" [label="yes"];
    "More tasks remaining?" -> "Dispatch final quality auditor for entire implementation" [label="no"];
    "Dispatch final quality auditor for entire implementation" -> "Use godmode:merge-protocol";
}

Prompt Templates

  • ./implementer-prompt.md - Dispatch builder subagent
  • ./spec-reviewer-prompt.md - Dispatch spec compliance auditor subagent
  • ./code-quality-reviewer-prompt.md - Dispatch code quality auditor subagent

Example Workflow

You: I'm using Delegated Execution to implement this plan.

[Read plan file once: docs/plans/feature-plan.md]
[Extract all 5 tasks with full text and context]
[Build task checklist from all tasks]

Task 1: Hook installation script

[Get Task 1 text and context (already extracted)]
[Dispatch builder subagent with full task text + context]

Builder: "Before I start - should the hook install at user level or system level?"

You: "User level (~/.config/godmode/hooks/)"

Builder: "Understood. Implementing now..."
[Later] Builder:
  - Implemented install-hook command
  - Added tests, 5/5 passing
  - Self-review: Noticed I missed --force flag, added it
  - Committed

[Dispatch spec compliance auditor]
Spec auditor: PASS - All requirements met, nothing extraneous

[Get git SHAs, dispatch quality auditor]
Quality auditor: Strengths: Good test coverage, clean code. Issues: None. Approved.

[Mark Task 1 complete]

Task 2: Recovery modes

[Get Task 2 text and context (already extracted)]
[Dispatch builder subagent with full task text + context]

Builder: [No questions, proceeds]
Builder:
  - Added verify/repair modes
  - 8/8 tests passing
  - Self-review: All good
  - Committed

[Dispatch spec compliance auditor]
Spec auditor: FAIL - Issues:
  - Missing: Progress reporting (spec says "report every 100 items")
  - Extra: Added --json flag (not requested)

[Builder fixes issues]
Builder: Removed --json flag, added progress reporting

[Spec auditor re-audits]
Spec auditor: PASS - Spec compliant now

[Dispatch quality auditor]
Quality auditor: Strengths: Solid. Issues (Important): Magic number (100)

[Builder fixes]
Builder: Extracted PROGRESS_INTERVAL constant

[Quality auditor re-audits]
Quality auditor: Approved

[Mark Task 2 complete]

...

[After all tasks]
[Dispatch final quality auditor]
Final auditor: All requirements met, ready to merge

Done!

Advantages

vs. Manual execution:

  • Subagents follow test-first naturally
  • Fresh context per task (no confusion)
  • Parallel-safe (subagents do not interfere)
  • Subagent can ask questions (before AND during work)

vs. Task Runner:

  • Same session (no handoff)
  • Continuous progress (no waiting)
  • Review checkpoints are automatic

Efficiency gains:

  • No file reading overhead (controller provides full text)
  • Controller curates exactly what context is needed
  • Subagent receives complete information upfront
  • Questions surfaced before work begins (not after)

Quality gates:

  • Self-review catches issues before handoff
  • Two-stage review: spec compliance, then code quality
  • Review loops ensure fixes actually work
  • Spec compliance prevents over/under-building
  • Code quality ensures implementation is well-crafted

Cost:

  • More subagent invocations (builder + 2 auditors per task)
  • Controller does more preparation (extracting all tasks upfront)
  • Review loops add iterations
  • But catches issues early (cheaper than debugging later)
Show full SKILL.md (220 more words)Show less

Guardrails

Never:

  • Start implementation on main/master branch without explicit user consent
  • Skip reviews (spec compliance OR code quality)
  • Proceed with unresolved issues
  • Dispatch multiple builder subagents in parallel (conflicts)
  • Make subagent read the plan file (provide full text instead)
  • Skip scene-setting context (subagent needs to understand where the task fits)
  • Ignore subagent questions (answer before letting them proceed)
  • Accept "close enough" on spec compliance (auditor found issues = not done)
  • Skip review loops (auditor found issues = builder fixes = audit again)
  • Let builder self-review replace actual review (both are needed)
  • Start quality review before spec compliance is approved (wrong order)
  • Move to next task while either review has open issues

If subagent asks questions:

  • Answer clearly and completely
  • Provide additional context if needed
  • Do not rush them into implementation

If auditor finds issues:

  • Builder (same subagent) fixes them
  • Auditor reviews again
  • Repeat until approved
  • Do not skip the re-audit

If subagent fails the task:

  • Dispatch a fix subagent with specific instructions
  • Do not try to fix manually (context contamination)

Connections

Required workflow skills:

  • godmode:workspace-isolation - REQUIRED: Set up isolated workspace before starting
  • godmode:task-planning - Creates the plan this skill executes
  • godmode:quality-gate - Code review template for auditor subagents
  • godmode:merge-protocol - Finalize development after all tasks

Subagents should use:

  • godmode:test-first - Subagents follow test-first for each task

Alternative workflow:

  • godmode:task-runner - Use for separate session instead of same-session execution

© NoobyGains, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files in skills/delegated-execution of NoobyGains/godmode.

  • SKILL.md
  • code-quality-reviewer-prompt.md
  • implementer-prompt.md
  • spec-reviewer-prompt.md

Open the folder on GitHubat commit 441103a

Compare with similar skills

Delegated Execution next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Delegated Execution compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Delegated Execution this skillNoobyGains/godmode107—~2.4kAutomated safety check: PassMIT
Executing Plans Inlineobra/superpowers297k2 repos~5.1kAutomated safety check: PassMIT
Interview Meaddyosmani/agent-skills103k6 repos~3.8kAutomated safety check: PassMIT
OpenSpec Guided OnboardingFission-AI/OpenSpec71k1 repos~4.5kAutomated safety check: PassMIT
Writing Plansgeeksblabla/stateofdev.ma16357 repos~661Automated safety check: PassNone
Subagent Driven DevelopmentAsvarox/allkaraoke26137 repos~1.2kAutomated safety check: PassNone

Similar skills

  • Executing Plans Inline

    obra/superpowers

    Has the agent carry out an implementation plan itself, task by task in the current session, keeping a ledger, proving each step with a test and ending with one whole-branch review.

    297k GitHub starsUsed in 2 repos~5.1k tokens
    Agent WorkflowsAuto-check passed
  • Interview Me

    addyosmani/agent-skills

    Asks one question at a time, each with a best guess attached, until the agent is about 95 percent sure what you really want, before any plan, spec or code.

    103k GitHub starsUsed in 6 repos~3.8k tokens
    Agent WorkflowsAuto-check passed
  • OpenSpec Guided Onboarding

    Fission-AI/OpenSpec

    Walks you through a complete OpenSpec workflow cycle with narration while doing real work in your codebase.

    71k GitHub starsUsed in 1 repo~4.5k tokens
    Agent WorkflowsAuto-check passed
  • Writing Plans

    geeksblabla/stateofdev.ma

    A skill your agent uses when design is complete and you need detailed implementation tasks for engineers with zero codebase context - creates comprehensive implementation plans with exact file…

    163 GitHub starsUsed in 57 repos~661 tokens
    Agent WorkflowsAuto-check passed
  • Subagent Driven Development

    Asvarox/allkaraoke

    A skill your agent uses when executing implementation plans with independent tasks in the current session

    261 GitHub starsUsed in 37 repos~1.2k tokens
    Agent WorkflowsAuto-check passed
  • Planning With Files

    jd-opensource/JoySafeter

    Implements Manus-style file-based planning for complex tasks.

    313 GitHub starsUsed in 19 repos~1.8k tokens
    Agent WorkflowsAuto-check: notes

More from NoobyGains/godmode

All 34 skills in this repo
  • Activation

    NoobyGains/godmode

    A skill your agent uses when starting any conversation - establishes how to locate and invoke skills, mandating Skill tool usage before ANY response including clarifying questions

    107 GitHub stars~2.4k tokensUpdated 7 mo ago
    Auto-check passed
  • Agent Messaging

    NoobyGains/godmode

    A skill your agent uses when dispatching subagents, composing prompts for teammates, structuring handoff reports, or managing context boundaries between agents.

    107 GitHub stars~3k tokensUpdated 7 mo ago
    Auto-check passed
  • Codebase Research

    NoobyGains/godmode

    A skill your agent uses when building ANY feature within an existing project - search the current codebase for existing patterns, conventions, similar implementations, and established approaches…

    107 GitHub stars~3.2k tokensUpdated 7 mo ago
    Auto-check: notes
  • Completion Gate

    NoobyGains/godmode

    A skill your agent uses when about to declare work done, fixed, or passing, before committing or opening PRs - demands executing verification commands and reading their output before making any…

    107 GitHub stars~1.6k tokensUpdated 7 mo ago
    Auto-check passed
  • Comprehension Check

    NoobyGains/godmode

    A skill your agent uses when implementing any substantial feature, multi-file modification, or architectural change - produces a plain-language walkthrough of every alteration so the developer can…

    107 GitHub stars~1.5k tokensUpdated 7 mo ago
    Auto-check passed
  • Deployment Advisor

    NoobyGains/godmode

    A skill your agent uses when making technology, hosting, or infrastructure decisions — recommends services, databases, and deployment strategies based on project requirements and what the user…

    107 GitHub stars~4k tokensUpdated 7 mo ago
    Auto-check: notes

Categories

Questions about Delegated Execution

What does Delegated Execution do?

A skill your agent uses when executing implementation plans with independent tasks in the current session. Delegated Execution is an agent skill from NoobyGains/godmode.

When should I use Delegated Execution?

Delegated Execution fits situations like: executing implementation plans with independent tasks in the current session; tasks that involve Planning.

How do I install Delegated Execution in Claude Code?

Run `npx skills add NoobyGains/godmode --skill delegated-execution -a claude-code`. Or copy the skill folder (skills/delegated-execution in NoobyGains/godmode) into .claude/skills/delegated-execution in your project. Claude Code loads it when a task matches its description.

How do I install Delegated Execution in Codex?

Run `npx skills add NoobyGains/godmode --skill delegated-execution -a codex`. Or copy the skill folder (skills/delegated-execution in NoobyGains/godmode) into .agents/skills/delegated-execution in your project. Codex loads it when a task matches its description.

Can I use Delegated Execution in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add NoobyGains/godmode --skill delegated-execution -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/delegated-execution, .gemini/skills/delegated-execution, .github/skills/delegated-execution and .opencode/skills/delegated-execution in your project.

What does Delegated Execution need to run?

SKILL.md names no scripts, command-line tools or credentials: Delegated Execution is instructions for the agent only.

Does Delegated Execution access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Delegated Execution safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Delegated Execution use?

Delegated Execution is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Delegated Execution use?

About 2.4k tokens (SKILL.md is roughly 9.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Delegated Execution?

Skills that share tags, products or a category with Delegated Execution: Executing Plans Inline (obra/superpowers, 297k stars), Interview Me (addyosmani/agent-skills, 103k stars), OpenSpec Guided Onboarding (Fission-AI/OpenSpec, 71k stars) and Writing Plans (geeksblabla/stateofdev.ma, 163 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Delegated Execution?

NoobyGains (a GitHub user) maintains it in NoobyGains/godmode, which has 107 GitHub stars. The repository holds 34 skills in this directory. The repository was last updated on March 9, 2026.

Source: NoobyGains/godmode on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.