tasker
By dowwie
Turn natural language project specs into executable task DAGs: interactively specify vision and behaviors, decompose into phased tasks with dependencies, execute via isolated AI subagents in a git-init'd directory, with checkpointing, crash recovery, and LLM/bash/pytest verification.
Component Overview
Install
npx claudepluginhub dowwie/tasker --plugin taskerComponent Details
Commands (3)
Agents (8)
Extract capabilities and behaviors from spec. Outputs JSON that MUST validate against schemas/capability-map.schema.json.
Phase 2 - Map behaviors to file paths. Outputs JSON to .tasker/artifacts/physical-map.json. Must validate against schema.
Phase 4 - Assign phases, identify steel thread, validate DAG. Updates task files with final phase assignments.
Phase 7 of /specify workflow - Analyze spec for weakness categories before export. Engages user to resolve critical weaknesses.
Phase 3 - Create individual task files from physical map. Each task is a separate JSON file in .tasker/tasks/. Enables parallel work and cleaner state tracking.
Execute a single task in isolation. Self-completing - calls tasker state directly and writes result file. Returns minimal status to orchestrator. Context-isolated - no memory of previous tasks.
Phase 4 - LLM-as-judge verification of task definitions during planning. Evaluates tasks against spec, strategy, and user preferences before execution begins.
LLM-as-judge verification of completed tasks. Evaluates implementation against acceptance criteria using a structured rubric. Returns pass/fail with reasoning.
Skills (2)
Hooks (1)
README
Tasker
Tasker is a spec-driven development workflow built for Claude Code. It covers the entire pipeline: spec -> plan -> execute.
Installation
curl -fsSL https://raw.githubusercontent.com/Dowwie/tasker/main/scripts/install.sh | bash -s -- --easy-mode
This installs the tasker CLI and registers the Claude Code plugin. After installation, start a new session:
/tasker:specify— develop a specification/tasker:plan— decompose into tasks/tasker:execute— implement and verify
Specify → Plan → Execute
Tasker enforces a three-stage pipeline.
Specify captures intent exhaustively. Edge cases, state transitions, and invariants are resolved before implementation begins.
Plan decomposes the specification into isolated, verifiable tasks with explicit dependencies.
Execute implements each task and verifies results against the spec.
By the time code is written, behavior is defined and implementation becomes translation.
What Makes This Work
Exhaustive discovery. Agents naturally stop asking after a few questions. Tasker uses reduce-while loops that continue until all requirement categories are covered. The loop pressure forces comprehensive specifications.
Steel thread first. Before building features, validate the architecture. The primary end-to-end flow is identified and implemented early; if the foundation is flawed, you discover it in days, not months.
Task decomposition protocol. Specifications are transformed into a directed acyclic graph through a structured six-phase process: logical decomposition, physical mapping, cross-cutting concerns, task definition, dependency analysis, and completeness audits. Every task is small enough to verify, specific enough to implement without questions.
Finite state machines as contracts. State machines serve two purposes: shaping acceptance criteria during implementation, and producing documentation for ongoing understanding. The FSM JSON is canonical; diagrams are derived.
Decision registry. Architectural decisions are captured in ADRs alongside specifications. Context is preserved, not lost to chat history.
Resumable Workflow
Stop anytime with tasker stop, resume with tasker resume. Checkpoints are created before each batch; result files track every task outcome; git commits mark progress. Work survives interruptions.
Similar Plugins
everything-claude-code
Battle-tested Claude Code plugin for engineering teams — 38 agents, 156 skills, 72 legacy command shims, production-ready hooks, and selective install workflows evolved through continuous real-world use
Uses power tools
Uses Bash, Write, or Edit tools