aw

Solid

Ships autonomous, end-to-end coding work — implement a feature or fix, all the way to a tested draft PR — from a single opt-in entry point. Detects the task tier (Micro / Lite / Full) and routes: Micro/Lite run single-pass in this context; Full hands off to the aw-planner → aw-executor agents. Use when the user asks to do a task "autonomously", "independently", "in isolation", "in a worktree", "end-to-end", "all the way to a PR", to "ship this", "land this", "take care of this", or "handle this without me" — or invokes `/aw` directly. Opt-in, not a wrapper on casual edits; the routing rule's exclusion list governs when to hold back. Triggers on "implement autonomously", "end-to-end", "in a worktree", "ship this", "/aw".

AI & Automation 13 stars 2 forks Updated yesterday MIT

Install

View on GitHub

Quality Score: 86/100

Stars 20%
38
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
80
License 10%
100
Description 5%
100

Skill Content

# Autonomous Workflow Dispatcher (`aw`) ## Identity You are the **dispatcher** — the single, opt-in entry point developers invoke for autonomous work. You do two things and nothing else of substance: 1. **Match the harness to the task** — detect the tier and route. Never force a heavy process onto a light task (research is explicit that always-planning wastes compute and *degrades* long-horizon performance — see [`references/anthropic-architecture-research.md`](../references/anthropic-architecture-research.md)). 2. **Own the self-improvement loop** — read lessons before deciding, write lessons after finishing, for **every** tier. This is what makes the whole workflow self-improving regardless of how lightweight the task was. You are invoked **deliberately** (a trigger phrase or `/aw`), not as a silent wrapper on every message. Stay thin: you route and own the loop; the actual planning/coding/testing lives in the skill, the companions, and the planner/executor agents. **You are a skill, so you run in the caller's context** — its tool grant, its conversation history, its delegation budget. Three consequences are load-bearing: - **The dispatch budget is spent at your caller's level, not one below it.** `aw-planner` / `aw-executor` are dispatched *from* the session that invoked you, so they sit one rung higher than they did under the retired `aw` agent and keep whatever nested dispatch the harness grants. That is the whole point of this being a skill ...

Details

Author
mthines
Repository
mthines/agent-skills
Created
4 months ago
Last Updated
yesterday
Language
JavaScript
License
MIT

Integrates with

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Solid

autonomous-workflow

The phase-based machinery (0–7) behind the `aw` dispatcher — task intake through tested PR delivery in an isolated Git worktree, with optional companion skills for planning, quality gates, TDD, UX, code quality, docs, and CI verification. Companions skip silently if not installed. NOT the entry point and not auto-triggered: a natural-language request to do work autonomously, end-to-end, in isolation, or in a worktree belongs to the `aw` skill, which detects the task tier and routes. Reach for this skill only to read or run the phase machinery directly, bypassing tier detection — invoke with /autonomous-workflow.

13 Updated yesterday
mthines
AI & Automation Listed

autonomous

Use when the user has agreed on a plan or selected from suggested options and wants the agent to execute the work autonomously without further instruction. Also use when the user issues a bare directive ("go", "proceed", "build X", "fix Y", "ship it", "be autonomous", "merge autonomously", "automerge", "all green") that would otherwise require the user to enumerate the bstack discipline ("think deeply through chain of dependencies, parallel agents and worktrees, address PR comments, CI green, update docs, complete autonomously"). Symptoms: user about to repeat their daily "do this properly and autonomously" sentence; agent tempted to skip planning / validation / docs / merge- loop to ship faster. Replaces a ~50-word ritual instruction with one invocation. Triggers on "autonomous", "full bstack", "/autonomous", "merge autonomously", "automerge", "all green", "be autonomous", "let it run", and on bare directives during execution mode.

3 Updated today
broomva
AI & Automation Listed

autopilot

Autonomous full-pipeline worker for the task loop. Runs research -> design -> plan -> execute-each-task for ONE queued goal, each phase in a FRESH subagent so every phase gets a clean context window, while this conductor holds only artifact paths + summaries. Invoked by the task-loop worker on `autopilot`-class tasks (or directly on a goal). Fully autonomous: critic subagents replace human design/plan approval; committing on the repo's working branch is the ship path; money/deletion/external-send/destructive-git are hard-stops.

4 Updated 1 weeks ago
Thrifthunter4you