byanombyte93· 23 skills
Zero-config goal-to-tasks engine (the Atlas engine). Takes any goal (software, pentest, business, learning), runs adaptive discovery via brainstorming, generates a validated spec, parses into TaskMaster tasks, and hands off to execution. Use when user says "PRD", "product requirements", "I want to build", invokes /atlas, or wants task-driven development.
$npx -y skills add anombyte93/prd-taskmaster --skill prd-taskmasterInstalls into the current project.
Run `npx skills use "https://github.com/anombyte93/prd-taskmaster" --skill "anombyte93/prd-taskmaster"` and follow the generated skill instructions now. Read its complete output, redirecting it to a temporary file first if necessary. Resolve relative paths from the supporting-files directory it provides.
Use the skills in "https://github.com/anombyte93/prd-taskmaster" that are relevant to the current task. Run `npx skills add "https://github.com/anombyte93/prd-taskmaster"` and select the relevant skills, then follow their instructions.
| 1 | # Turn any goal into shipped code. |
| 2 | |
| 3 | **prd-taskmaster** by [Atlas AI](https://atlas-ai.au) is an open-source engine for Claude Code |
| 4 | that takes a one-line goal, interviews you like a senior PM, writes a **graded, |
| 5 | placeholder-proof PRD**, compiles it into a **dependency-ordered task graph**, and executes every |
| 6 | task with **verification evidence** — so "done" means proven, not claimed. |
| 7 | |
| 8 | Free and MIT, forever. |
| 9 | |
| 10 | > ⚠️ **Pre-alpha — under active development.** Atlas was recently consolidated into this engine |
| 11 | > and the newer systems (fleet orchestration, backend abstraction, token economy) have **not been |
| 12 | > fully tested in the wild yet**. Expect rough edges and breaking changes between releases, pin a |
| 13 | > version if you need stability, and please [report what breaks](https://github.com/anombyte93/prd-taskmaster/issues). |
| 14 | > No warranty beyond the MIT license. **Atlas Pro is not generally available** — it is a private |
| 15 | > pilot (see below). |
| 16 | |
| 17 | Atlas has four structural moats: |
| 18 | |
| 19 | - **cross-vendor fleet** — Claude, Codex, and Gemini run as separate quota pools instead of one |
| 20 | brittle model lane. |
| 21 | - **Engine-enforced unfakable gates** — `validate-tasks`, evidence checks, and `SHIP_CHECK_OK` |
| 22 | make completion a deterministic state, not a claim. |
| 23 | - **persistent vendor-neutral `tasks.json`** — your PRD, task graph, and execution state stay as |
| 24 | plain repo files that survive vendor swaps. |
| 25 | - **token-economy cost ledger** — every orchestrated model call records routing, exit, latency, |
| 26 | and escalation so cheap models do cheap work and expensive models justify themselves. |
| 27 | |
| 28 | **Atlas speaks TaskMaster natively — but doesn't need it.** Existing TaskMaster projects get a |
| 29 | migration funnel: install `task-master-ai` only when you want the TaskMaster backend, while the |
| 30 | native backend keeps the same validated task graph available without that prerequisite. |
| 31 | |
| 32 | ``` |
| 33 | Grade: GOOD ▰▰▰▰▰▰▰▰▱▱ 49/57 (86%) · 0 placeholders · 14 tasks parsed |
| 34 | ``` |
| 35 | |
| 36 | [](#project-status) |
| 37 | [](LICENSE) |
| 38 | [](https://github.com/anombyte93/prd-taskmaster/stargazers) |
| 39 | [](https://atlas-ai.au) |
| 40 | [](#whats-open-whats-not) |
| 41 | |
| 42 | --- |
| 43 | |
| 44 | ## How it works |
| 45 | |
| 46 | ``` |
| 47 | goal → discovery interview → graded PRD → dependency-ordered task graph → verified execution |
| 48 | ``` |
| 49 | |
| 50 | 1. **Preflight** — detects your environment (native backend, optional TaskMaster backend, model CLIs, research) and configures it. Zero setup questions. |
| 51 | 2. **Discovery** — an adaptive, one-question-at-a-time interview captures your real constraints. |
| 52 | 3. **Generate** — writes a PRD, scores it against deterministic quality checks (letter grade), then parses it into a task graph with complexity scores and full subtask coverage. |
| 53 | 4. **Handoff** — detects what you have installed and recommends one execution mode. |
| 54 | 5. **Execute** — a CDD-gated loop implements each task and proves it with evidence, ending in a deterministic `SHIP_CHECK_OK` token. |
| 55 | |
| 56 | --- |
| 57 | |
| 58 | ## Quickstart |
| 59 | |
| 60 | 90 seconds to your first run. |
| 61 | |
| 62 | ### Path 1 — one-liner (recommended) |
| 63 | |
| 64 | ```bash |
| 65 | curl -fsSL https://atlas-ai.au/install | bash |
| 66 | # installs the skill + prd_taskmaster package |
| 67 | # TaskMaster install is optional — unlocks the TaskMaster backend |
| 68 | ``` |
| 69 | |
| 70 | ### Path 2 — Claude Code plugin |
| 71 | |
| 72 | ```bash |
| 73 | # add the marketplace, then install the plugin |
| 74 | /plugin marketplace add anombyte93/prd-taskmaster |
| 75 | /plugin install prd |
| 76 | |
| 77 | # optional — unlocks the TaskMaster backend |
| 78 | npm install -g task-master-ai |
| 79 | ``` |
| 80 | |
| 81 | ### First run |
| 82 | |
| 83 | Open any project in Claude Code and type: |
| 84 | |
| 85 | ``` |
| 86 | /prd:atlas (or /prd:go, or just say: "I want to build …") |
| 87 | ``` |
| 88 | |
| 89 | Requires Python 3.11+ and Linux / macOS / WSL. The free engine needs **no paid API key** — it |
| 90 | uses the model CLIs you already have; an optional local research proxy can be plugged in |
| 91 | (bring your own — not bundled). npm installs run a `postinstall` step that pip-installs the |
| 92 | MCP server's Python deps (non-fatal warning if pip is unavailable). |
| 93 | |
| 94 | --- |
| 95 | |
| 96 | ## What "verified" means |
| 97 | |
| 98 | Most AI coding tools tell you a task is done. This one makes "done" provable: |
| 99 | |
| 100 | - **Graded PRDs.** Every spec is scored against deterministic checks (EXCELLENT / GOOD / ACCEPTABLE / NEEDS WORK). Placeholders (`TBD`, `{{...}}`, `TODO` — bare or bracketed) are a hard fail: the grade floors to NEEDS WORK and `validate-prd` exits non-zero. |
| 101 | - **A real task graph.** Requirements become backend-neutral `tasks.json` tasks with dependencies, complexity scores, and full subtask coverage — not a flat checklist. |
| 102 | - **Evidence-gated execution.** Each task is implemented and must produce execution evidence before it counts as done. |
| 103 | - **A completion token you can trust.** `SHIP_CHECK_OK` is emitted only when every gate passes — and a single non-zero |