Skip to content
Skills Library
AI & agents · Automation

subagent-driven

/subagent-driven

Use when a user says execute with subagents or orchestrate, or hands over an ordered multi-task plan. Not for credential, paid, or deployment work, or any mutation outside the skill''s designated workspace.

Licence
Apache-2.0
Last repository change
10.11.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
10
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 10.11.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use when a user says execute with subagents or orchestrate, or hands over an ordered multi-task plan. Not for credential, paid, or deployment work, or any mutation outside the skill''s designated workspace.

Original author description

Use when a user says execute with subagents or orchestrate, or hands over an ordered multi-task plan. Not for credential, paid, or deployment work, or any mutation outside the skill''s designated workspace.

How it works

  1. What the plan must give you
  2. Run each task through implement, review, and gate
  3. Close the branch and ship it whole
  4. Recover dead workers without destroying the tree
Original SKILL.md headings · 49 lines, 1,206 words
SKILL.md preview
---
name: subagent-driven
description: 'Use when a user says execute with subagents or orchestrate, or hands over an ordered multi-task plan. Not for credential, paid, or deployment work, or any mutation outside the skill''s designated workspace.'
---

# Subagent-driven development

An ordered multi-task plan becomes a chain of fresh subagents, each implementing one task, each gated by its own reviewer, with the whole branch reviewed once more before an atomic ship. You orchestrate. Workers implement and review in isolation. The ledger at `.outline/sdd/progress.md` tracks completion, and `git log` rebuilds it when sessions compact.

Saying "execute with subagents" or handing over an ordered multi-task plan invokes this skill. Credential, paid, and deployment work stay out, as does any mutation outside the designated workspace. Publishing the branch via git-branchless `submit` needs explicit human invocation. All other writes (commits, briefs, reports, diff packages, the ledger) stay local, with version control as the rollback.

## What the plan must give you

The plan file defines task boundaries, file scopes, and done criteria. Select a model or agent tier for each dispatch. Pass the model argument when the dispatch tool accepts one for that agent. When the tool rejects a per-call model, select the agent tier instead and record the choice in the ledger. An omitted model inherits the session model, which is usually the most expensive, so set one explicitly. Fresh subagents see only what gets put in front of them: the task brief path, relevant context from earlier tasks, and every decision or interface the implementer must respect.

Before execution, scan the plan for self-conflicts (tasks contradicting each other, Global Constraints, or plan-mandated defects). Batch every finding into one user question. A clean scan proceeds silently.

Check the recovery ledger before starting: `cat "$(git rev-parse --show-toplevel)/.outline/sdd/progress.md"`. Tasks marked complete there are done. Resume at the first incomplete task. When the ledger is missing, reconstruct it from `git log` using the plan task order and the timestamps of commits matching each task concern. If no task commit exists yet, create the ledger with every task incomplete before the first dispatch.

## Run each task through implement, review, and gate

Work tasks in order, one at a time:

1. Split the task into one-concern work with explicit file boundaries. Two tasks editing the same file are not independent. Sequence or merge them.
2. Run `scripts/task-brief PLAN_FILE N`. It extracts the full task text to a uniquely named file and prints the path. That brief is the single source of requirements. The plan must head each task `Task N`: the script matches only that heading form and exits 3 for any other, so write the brief by hand for a plan with other headings.
3. Record the BASE commit (current HEAD) before dispatching.
4. Dispatch one fresh implementer with `references/implementer-prompt.md` filled in. Fresh means no carried context and no resumed worker. Name the model or tier, as the section above requires.
5. The implementer works, verifies, commits one concern, self-reviews, writes a full report to the report file, and returns a short status: DONE, DONE_WITH_CONCERNS, NEEDS_CONTEXT, or BLOCKED.
6. Resolve the status before moving on. Missing context gets supplied and the task re-dispatches. Reasoning problems re-dispatch on a more capable model. Oversized tasks split first. Plan errors escalate to the user. A worker saying it is stuck always triggers a change of some kind before retry. Never retry unchanged.
7. Run `scripts/review-package BASE HEAD`. It writes one file (commit list, stat summary, full diff with context) and prints the path. Use the recorded BASE, never HEAD~1.
8. Dispatch a fresh reviewer with `references/task-reviewer-prompt.md` filled in, handing it the brief path, report path, diff-package path, and the verbatim Global Constraints.
9. Gate on audit clean and verifier green, then mark the task complete. Critical or Important findings dispatch one fix worker with the complete findings list, followed by re-review. An audit that cannot clear aborts the chain rather than building on it. Never squash or force through.

Requirements living in unchanged code or spanning tasks come back from reviewers as Cannot Verify from Diff items. Those never block: resolve each centrally before marking the task complete. A confirmed gap is a failed spec review. Return to the implementer, then re-review.

Never mark a task complete, run the final review, or report while a dispatched worker has not returned its status, and never do a worker's task yourself while it runs. A worker that returns nothing because it died, hung, or was lost goes through the recovery section below and is relaunched once with a changed brief that names the work already done; a second failure marks the task BLOCKED and stops the chain.

A bare follow-up such as 'continue', 'orchestrate', or 'orchestrate more' resumes this run from the todo list or ledger and dispatches the next ready wave, and a finished wave is never a stopping condition. If a wait call aborts, check the worker's report file and its commits, never its agent handle, then resume from them. When a provider limit ends the run, write the resume state to the ledger and report the restart command.

## Close the branch and ship it whole

After every task lands, run `scripts/review-package MERGE_BASE HEAD` with MERGE_BASE from `git merge-base main HEAD`. Dispatch the final reviewer on the most capable model, pointed at the Minor findings the ledger accumulated. Its findings dispatch one fix worker with the complete list, then re-review.

Ship through the atomic path: sort work into atomic commits in detached HEAD. Publish with git-branchless `submit` only when the user explicitly asks for publication. Otherwise stop after the local atomic commits and report the branch name and commit list.

Then run the closing chain in this order. Complete the implementation path first. Run this skill own review and fix gate to green (audit clean and verifier green per task, then the whole-branch review), bounded at 3 fix cycles per unit. Past that bound, stop as blocked or non-converged instead of widening scope to unrelated code. Finish with an offensive simplify pass: re-derive the general case from contracts, delete old structure with no shims, aliases, or flags, collapse special cases, migrate every caller in the same change, keep one concern per atomic commit. Ask first before removing any live consumer surface, and stay inside this skill authority throughout. Run the verifier after each increment and revert the increment on red. End with a simplify compression pass over dead branches, duplicated logic, and one-use wrappers, with behavior preserved and checks green.

## Recover dead workers without destroying the tree

A worker dying mid-task leaves a dirty tree. Inspect first (`git status`, `git diff`) and save that worker's uncommitted diff and its untracked files under the workspace first, then revert only that worker's changes: discard its edits, remove the stray files it created, leave pre-existing uncommitted work untouched. Never blanket-reset or `git clean` the whole tree. A dead worker never resumes onto a dirty tree, and the next task never builds on uncommitted partial work.

Before retrying, inspect the designated workspace, actual commit objects, dirty and untracked state, report, and ledger. Verify which outcomes exist and which remain incomplete. Continue only the remaining work in that preserved workspace, with a brief naming completed work that must not repeat. Provider or quota failures with no productive execution are resource blockers, never evidence that a full redispatch will help. Partial work and ownership carry over, and recovery grants no new push, merge, or publication authority.
Files in this package (10)
  • SKILL.md 8 KB
  • agents/openai.yaml 1 KB
  • references/example-workflow.md 2 KB
  • references/implementer-prompt.md 6 KB
  • references/parallel-dispatch.md 1 KB
  • references/recovery.md 1 KB
  • references/task-reviewer-prompt.md 8 KB
  • scripts/review-package 1 KB
  • scripts/sd-workspace 1 KB
  • scripts/task-brief 2 KB

Versions

RepositoryScoreLicence
This page · gosuda/dalcom-skills100Apache-2.0
OutlineDriven/outline-driven-development100Apache-2.0

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

Feedback and reports

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