From groundwork
Executes remaining tasks in parallel using agent teams for context isolation. Each task runs in its own teammate session. For large batches (>5 tasks) where context accumulation is a concern.
How this skill is triggered — by the user, by Claude, or both
Slash command
/groundwork:just-do-it-swarmingThis skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
Executes all remaining tasks using **agent teams** for context isolation. Each task runs in a separate teammate session with its own context window. Teammates are full Claude Code sessions that can spawn subagents (Plan, task-executor, 9 validators), solving the context accumulation problem of inline batch execution.
Executes all remaining tasks using agent teams for context isolation. Each task runs in a separate teammate session with its own context window. Teammates are full Claude Code sessions that can spawn subagents (Plan, task-executor, 9 validators), solving the context accumulation problem of inline batch execution.
When to use this vs /groundwork:just-do-it:
/groundwork:just-do-it-swarming) for large batches (>5 tasks) where context accumulation is a concern/groundwork:just-do-it for small batches or when agent teams are not availableRequirement: Agent teams must be enabled (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1" in settings.json env section).
Model: Teammates spawn with model: "opus" for extended context.
Your current effort level is {{effort_level}}.
Skip this step silently if effort is high, xhigh, or max (the scale is low < medium < high < xhigh < max, so xhigh and max are already above high) AND you are Sonnet or Opus.
If effort is low or medium (i.e. below high), you MUST show the recommendation prompt — regardless of model.
If you are not Sonnet or Opus, you MUST show the recommendation prompt - regardless of effort level.
Otherwise → use AskUserQuestion:
{
"questions": [{
"question": "Do you want to switch? Team orchestration with worktree coordination across agents benefits from consistent reasoning.\n\nTo switch: cancel, run `/effort high` (and `/model sonnet` if on Haiku), then re-invoke this skill.",
"header": "Recommended: Sonnet or Opus at high effort",
"options": [
{ "label": "Continue" },
{ "label": "Cancel — I'll switch first" }
],
"multiSelect": false
}]
}
If the user selects "Cancel — I'll switch first": output the switching commands above and stop. Do not proceed with the skill.
Before loading tasks, ensure project context is resolved:
.groundwork.yml exist at the repo root?
{{project_name}} non-empty?
Skill(skill="groundwork:select-project") to select a project, then restart this skill.{{project_name}}, specs at {{specs_dir}}/..groundwork.yml).AskUserQuestion:
"You're working from
<cwd>(inside [cwd-project]), but the selected Groundwork project is [selected-project] ([selected-project-path]/). What would you like to do?"
- "Switch to [cwd-project]"
- "Stay with [selected-project]" If the user switches, invoke
Skill(skill="groundwork:select-project").
{{specs_dir}}/ paths will resolve to the correct location.Read the tasks file to find all tasks:
{{specs_dir}}/tasks.md{{specs_dir}}/tasks/ (aggregated in sorted order)Parse all tasks and extract:
TASK-001)Not Started, In Progress, Complete, Blocked)Blocked by: field)Build dependency graph and calculate execution order:
Detection: Check for file first (takes precedence), then directory.
Present a summary to the user:
Mode: Agent Teams (swarming) Total tasks: X Already complete: Y Remaining: Z
Each task runs in a separate teammate session with its own context window:
Each task also executes in an isolated git worktree:
task/TASK-NNN created from current HEAD.worktrees/TASK-NNNAsk for confirmation before proceeding.
If user declines, stop and suggest alternatives:
/groundwork:just-do-it for inline execution (no agent teams required)/groundwork:work-on N to work on a specific task/groundwork:work-on-next-task to work on just the next available taskBefore creating the team, verify agent teams are available by checking if the team creation tools are accessible.
If agent teams are not enabled:
"Agent teams are required for swarming mode but are not enabled. To enable them, add this to your settings.json:
{ "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }Alternatively, use
/groundwork:just-do-itfor inline batch execution (no agent teams required)."
Stop here if not enabled.
Before spawning any teammates, load the work-on skill content so it can be embedded in each teammate's prompt:
**/work-on/SKILL.md within the groundwork plugin directory.--- delimited block at the top of the file) and keep everything after it. This is the work-on workflow content.EXECUTE_TASK_WORKFLOW: Hold this content for use in the teammate spawn prompts below.CRITICAL: Embed the workflow VERBATIM. Do not summarize, condense, rewrite, or adapt the workflow text. The teammate needs the full, unmodified workflow to follow it step-by-step. Summarization loses gate conditions (e.g. mandatory validation before merge) that prevent broken tasks from being merged.
Determine execution mode from the user's argument or request:
--parallel argument or user requests it): Independent tasks execute simultaneously in separate teammates.Create an agent team. Then for each remaining task in dependency order:
Read the task section from {{specs_dir}}/tasks.md (or aggregated from {{specs_dir}}/tasks/) to extract the full task definition (goal, action items, acceptance criteria, dependencies).
Announce start: "Starting TASK-NNN: [Title] (teammate session)"
Update task status to **Status:** In Progress in the tasks file.
Spawn a teammate with model: "opus" to execute the task. The teammate's spawn prompt must include:
You are executing a single task as part of an automated batch run.
GROUNDWORK_BATCH_MODE=true — do NOT use AskUserQuestion. Proceed automatically.
PROJECT ROOT: [absolute path to project root]
SPECS DIR: {{specs_dir}}
TASK IDENTIFIER: TASK-NNN
TASK TITLE: [Title]
TASK DEFINITION:
[Full task section from tasks file: goal, action items, acceptance criteria, dependencies]
EXECUTE-TASK WORKFLOW:
[EXECUTE_TASK_WORKFLOW loaded in Step 2.7]
INSTRUCTIONS:
1. Follow the EXECUTE-TASK WORKFLOW above starting from Step 1 (Parse Task Identifier).
- Skip Step 0 (context already resolved by the lead).
- TASK IDENTIFIER and TASK DEFINITION are provided above — use them directly.
- GROUNDWORK_BATCH_MODE is true — auto-proceed all confirmations.
2. When all the steps of the workflow are complete, report:
- Success: "TASK-NNN: SUCCESS — [one-line summary]"
Include validation results per agent:
VALIDATION: code-quality=[N] test-quality=[N] security=[N] spec-alignment=[N] architecture=[N] simplification=[N] housekeeping=[N] performance=[N] design-consistency=[N]
(where [N] is the number of iterations each agent required to pass)
- Failure: "TASK-NNN: FAILURE — [one-line reason]"
Wait for teammate to complete. Monitor via the shared task list.
Collect result from the teammate's completion message.
Verify workflow compliance: Parse the teammate's completion message for validation evidence.
VALIDATION: line with per-agent iteration counts (e.g., code-quality=2 test-quality=1 ...).SendMessage:
"Your completion report is missing the VALIDATION line with per-agent iteration counts. Run the validation loop (Step 7.5 of the work-on workflow) and report back with: VALIDATION: code-quality=[N] test-quality=[N] security=[N] spec-alignment=[N] architecture=[N] simplification=[N] housekeeping=[N] performance=[N] design-consistency=[N]"
Update task status:
**Status:** Complete in the tasks fileShut down the teammate before spawning the next one. This ensures each task gets a completely clean context.
Log result: "Completed TASK-NNN: [Title] — [one-line summary]"
On Failure: Report the failed task, reason, tasks completed this session, and tasks remaining. Note that the failed task's worktree is preserved at .worktrees/TASK-NNN for investigation. Clean up the team.
--parallel)Build dependency groups: Partition tasks into levels based on the dependency graph. Level 0 = tasks with no dependencies. Level 1 = tasks whose dependencies are all in Level 0. Etc.
Process one level at a time:
For each dependency level:
a. Determine the independent tasks in this level that are not yet complete.
b. Cap concurrency: Spawn at most 5 teammates simultaneously (to control token cost). If more tasks than the cap, queue the rest.
c. Spawn teammates for each task in the level, each with model: "opus" and the same spawn prompt as sequential mode.
d. Wait for all teammates in this level to complete. As teammates finish, collect results. If any task fails, stop spawning new teammates but let running teammates finish.
e. Verify workflow compliance for each teammate before shutting it down:
VALIDATION: line with per-agent iteration counts.SendMessage:
"Your completion report is missing the VALIDATION line with per-agent iteration counts. Run the validation loop (Step 7.5 of the work-on workflow) and report back with: VALIDATION: code-quality=[N] test-quality=[N] security=[N] spec-alignment=[N] architecture=[N] simplification=[N] housekeeping=[N] performance=[N] design-consistency=[N]"
f. Shut down all teammates in this level before proceeding to the next.
Continue to next dependency level only after all tasks in the current level are complete.
On Failure in Parallel Mode: Report the failed task(s). If multiple tasks in the same level fail, report all of them. Stop processing further levels. Clean up the team.
Clean up the agent team, then report:
## Swarming Batch Execution Complete
**Mode:** Agent Teams (swarming)
**Session Summary:**
- Tasks completed: X
- Total tasks complete: Y/Z
- All worktrees merged and cleaned up
- Agent team cleaned up
### Completed Tasks
| Task | Title | Branch | Status |
|------|-------|--------|--------|
| TASK-001 | [Title] | task/TASK-001 | Merged |
| TASK-002 | [Title] | task/TASK-002 | Merged |
...
### Worktree Summary
- Worktrees created: X
- Successfully merged: X
- Cleaned up: X
### Context Isolation Summary
- Teammate sessions spawned: X
- Each task ran in its own context window
- Lead context remained clean throughout execution
### Next Steps
- Run `/source-product-specs-from-code` to update specs with any implementation changes
- Plan next phase if milestone complete
- Review merged changes with `git log --oneline -10`
| Situation | Response |
|---|---|
| No tasks file | "Tasks file not found. Run /groundwork:create-tasks to generate tasks." |
| No remaining tasks | "All tasks are already complete! Nothing to execute." |
| All remaining blocked | "All remaining tasks are blocked. Cannot proceed automatically." |
| Single task remaining | Execute normally (still uses a teammate for context isolation) |
| Agent teams not enabled | Report error and suggest enabling or using /groundwork:just-do-it |
| Teammate crashes/hangs | Report failure for that task, preserve worktree, clean up team, stop batch |
| Merge conflict in teammate | Teammate reports failure, lead stops batch and reports the conflict |
npx claudepluginhub etr/groundworkExecutes all remaining tasks in sequence until completion, stopping on first failure. Includes pre-flight recommendation for Sonnet/Opus at high effort and monorepo project context resolution.
Creates and manages a persistent agent team to execute tasks from a task board in parallel. Spawns teammates, assigns work with dependency ordering, and coordinates until completion.