Autonomously execute ALL tasks from the backlog until complete. Runs in a continuous loop — picks task, implements via subagent, moves to done, repeats. No user prompts between tasks. Follows task-board workflow (backlog → in-progress → done).
This skill autonomously executes ALL tasks from the task board until the backlog is empty. It runs in a continuous loop without stopping between tasks.
Task Board Flow: task-board/backlog/ → task-board/in-progress.md → task-board/done/
AUTONOMOUS MODE: This skill does NOT stop between tasks. It continues until all tasks are complete or a critical blocker occurs.
ALL work flows through task-board/ — this is non-negotiable.
backlog/ → in-progress.md → done/overview.md is the source of truth for prioritiesABSOLUTELY NO git commands — not by the main agent, not by subagents.
git add, git commit, git push, git pull, git checkout, git branch, etc.git status, git diff, git log (even read-only commands)gitWhy: The user handles all git operations. The push-code skill handles commits when requested.
Each task MUST be executed using the Task tool with a subagent:
model: "sonnet" — multi-file architectural changes, complex business logic, intricate state managementTasks are numbered for dependency reasons. Execute them sequentially, in order:
Every task MUST be verified before marking complete:
# Backend verification
dotnet build --configuration Release
# Frontend verification (if frontend changes)
cd client && npm run build
# Manual browser check for UI changes
Tasks without build verification are INCOMPLETE.
Subagents MUST use built-in tools instead of bash equivalents:
| NEVER USE | ALWAYS USE |
|---|---|
cat, head, tail | Read tool |
echo >, cat <<EOF | Write tool |
sed, awk | Edit tool |
find, ls (for search) | Glob tool |
grep, rg | Grep tool |
NEVER change composite key columns (Match PK, Round PK, LeagueMember PK) without:
.claude/templates/domain-change-proposal.md)Use this skill when the user requests:
Read task-board/overview.md to see what's next.
If no tasks exist: Ask the user if they want to:
backlog-scan to discover tasksfeature-planning to plan a specific featurePick the first numbered task from the backlog (unless blocked or user specifies otherwise).
Decision criteria:
If the top priority is blocked, move to the next unblocked item.
task-board/in-progress.md with the active task detailsbacklog/ but mark status as "In Progress"Important: Only 1 task at a time. If in-progress already has a task, ask user if they want to finish it first.
Thoroughly understand the task plan:
STOP and ask the user if:
Only proceed after all uncertainties are resolved.
Evaluate if the task is appropriately sized:
If task is too complex:
backlog/ for each sub-taskoverview.md with the new breakdownComplexity indicators:
If the task file doesn't already have a detailed implementation plan, add one:
## Implementation Plan
**Phase 1: Backend** (if applicable)
- [ ] Domain entity changes
- [ ] MediatR handler (Command/Query)
- [ ] DTOs and mapping profiles
- [ ] FluentValidation rules
- [ ] AppDbContext configuration
- [ ] Migration (if needed)
**Phase 2: API** (if applicable)
- [ ] Controller endpoint
- [ ] Authorization policy
**Phase 3: Frontend** (if applicable)
- [ ] TypeScript types (index.d.ts)
- [ ] React Query hook
- [ ] Zod schema
- [ ] Components
- [ ] Routes
**Phase 4: Verification**
- [ ] `dotnet build --configuration Release`
- [ ] `cd client && npm run build`
- [ ] Manual browser check
Mark the task as "In Progress" in task-board/overview.md.
Use the Task tool to spawn a subagent:
Task tool:
subagent_type: "general-purpose"
description: "Implement [short description]"
prompt: |
Implement the task specified in:
task-board/backlog/NNN-TYPE-description.md
READ CLAUDE.md FIRST — it contains all project patterns, domain invariants, and conventions.
READ docs/frontend-rules.md if this involves frontend work.
Follow implementation order: Domain → Application → Persistence → Infrastructure → API → Frontend
CRITICAL RESTRICTIONS:
1. Work ONLY on this task from task-board/ — no ad-hoc work
2. NEVER use git commands (git add, commit, push, status, diff, etc.)
3. Use Read tool (NOT cat/head/tail)
4. Use Write tool (NOT echo/cat heredoc)
5. Use Edit tool (NOT sed/awk)
6. Use Glob tool (NOT find/ls for search)
7. Use Grep tool (NOT grep/rg bash commands)
8. CHECK OFF acceptance criteria as you complete them (change [ ] to [x])
9. NEVER modify composite key columns without explicit task approval
10. Run `dotnet build --configuration Release` after backend changes
11. Run `cd client && npm run build` after frontend changes
When done, provide a summary of:
- Files created/modified
- All acceptance criteria status
- Build verification results
- Any issues encountered
Backend (.NET Clean Architecture):
Domain/Application/{Feature}/Commands/ or Queries/
Result<T> using the Result patternBaseApiController, use HandleResult<T>()Frontend (React 19):
lib/types/index.d.tslib/hooks/use{Feature}.tslib/schemas/{feature}Schema.tsfeatures/{feature}/# Backend (from project root)
dotnet run --project API
dotnet build --configuration Release
# Frontend (from client/)
cd client && npm run dev
cd client && npm run build
cd client && npm run lint
CRITICAL: Update acceptance criteria checkboxes before marking complete:
- [ ] to - [x] for each completed itemVerification checklist:
dotnet build --configuration Release passescd client && npm run build passes (if frontend changes)Then finalize:
backlog/ to done/in-progress.md — clear the active taskoverview.md — remove from priorities, add to recently completed, update statisticsCRITICAL: This skill runs ALL tasks automatically until backlog is empty.
LOOP until backlog is empty:
1. Read overview.md to get the FIRST numbered task
2. Update in-progress.md with task details
3. Spawn subagent with Task tool
4. Subagent implements and verifies
5. Move task to done/
6. Update overview.md
7. AUTOMATICALLY continue to next task (NO user prompt needed)
DO NOT STOP between tasks. Continue until:
Ask the user:
The backlog is currently empty. Would you like me to:
1. Run `backlog-scan` to discover tasks?
2. Run `feature-planning` to plan a specific feature?
3. Wait for you to manually create tasks?
Identify the blocker and skip to next unblocked task. Inform user of the skip.
ALWAYS ask clarifying questions before proceeding.
Break it down into sub-tasks, create new files in backlog/, and start with the first sub-task.
task-board/ (never work outside the task board system)dotnet build + npm run build)task-board/done/ with Resolutionoverview.md updated after each completionCLAUDE.md — Project-wide instructions and domain invariantsdocs/frontend-rules.md — Frontend conventionstask-board/overview.md — Current priorities.claude/skills/task-board/SKILL.md — Planning skill.claude/skills/push-code/SKILL.md — Commit and push skill