# atlas

Adopt this skill: https://proskills.md/skills/other/anombyte93-prd-taskmaster-skills-atlas

Page: https://proskills.md/skills/other/anombyte93-prd-taskmaster-skills-atlas
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/atlas/SKILL.md
size: 703
upstream: https://github.com/anombyte93/prd-taskmaster/blob/main/skills/atlas/SKILL.md

```text
---
name: atlas
description: >-
  The Atlas engine — turn any goal into a validated PRD and an executable, verified
  task graph. Brand-name entrypoint; a thin alias for the `go` orchestrator. Use when
  the user types /prd:atlas, says "I want to build", or asks for a PRD / task-driven build.
user-invocable: true
allowed-tools:
  - Skill
---

# atlas (entrypoint alias)

This is the brand-name entrypoint for the Atlas engine. It holds no procedure of its
own — **immediately invoke the `go` orchestrator** via the Skill tool (`/prd:go`).

`go` reads pipeline state and dispatches to the correct phase
(SETUP → DISCOVER → GENERATE → HANDOFF → EXECUTE). Do not duplicate that routing here.
```

## File: README.md
upstream: https://github.com/anombyte93/prd-taskmaster/blob/main/README.md

````text
# Turn any goal into shipped code.

**prd-taskmaster** by [Atlas AI](https://atlas-ai.au) is an open-source engine for Claude Code
that takes a one-line goal, interviews you like a senior PM, writes a **graded,
placeholder-proof PRD**, compiles it into a **dependency-ordered task graph**, and executes every
task with **verification evidence** — so "done" means proven, not claimed.

Free and MIT, forever.

> ⚠️ **Pre-alpha — under active development.** Atlas was recently consolidated into this engine
> and the newer systems (fleet orchestration, backend abstraction, token economy) have **not been
> fully tested in the wild yet**. Expect rough edges and breaking changes between releases, pin a
> version if you need stability, and please [report what breaks](https://github.com/anombyte93/prd-taskmaster/issues).
> No warranty beyond the MIT license. **Atlas Pro is not generally available** — it is a private
> pilot (see below).

Atlas has four structural moats:

- **cross-vendor fleet** — Claude, Codex, and Gemini run as separate quota pools instead of one
  brittle model lane.
- **Engine-enforced unfakable gates** — `validate-tasks`, evidence checks, and `SHIP_CHECK_OK`
  make completion a deterministic state, not a claim.
- **persistent vendor-neutral `tasks.json`** — your PRD, task graph, and execution state stay as
  plain repo files that survive vendor swaps.
- **token-economy cost ledger** — every orchestrated model call records routing, exit, latency,
  and escalation so cheap models do cheap work and expensive models justify themselves.

**Atlas speaks TaskMaster natively — but doesn't need it.** Existing TaskMaster projects get a
migration funnel: install `task-master-ai` only when you want the TaskMaster backend, while the
native backend keeps the same validated task graph available without that prerequisite.

```
Grade: GOOD  ▰▰▰▰▰▰▰▰▱▱  49/57 (86%) · 0 placeholders · 14 tasks parsed
```

[![status: pre-alpha](https://img.shields.io/badge/status-pre--alpha-orange.svg)](#project-status)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![GitHub stars](https://img.shields.io/github/stars/anombyte93/prd-taskmaster)](https://github.com/anombyte93/prd-taskmaster/stargazers)
[![works with](https://img.shields.io/badge/works_with-Claude%20%C2%B7%20Codex%20%C2%B7%20Gemini-8A2BE2)](https://atlas-ai.au)
[![free engine](https://img.shields.io/badge/engine-MIT%20free%20forever-brightgreen)](#whats-open-whats-not)

---

## How it works

```
goal → discovery interview → graded PRD → dependency-ordered task graph → verified execution
```

1. **Preflight** — detects your environment (native backend, optional TaskMaster backend, model CLIs, research) and configures it. Zero setup questions.
2. **Discovery** — an adaptive, one-question-at-a-time interview captures your real constraints.
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.
4. **Handoff** — detects what you have installed and recommends one execution mode.
5. **Execute** — a CDD-gated loop implements each task and proves it with evidence, ending in a deterministic `SHIP_CHECK_OK` token.

---

## Quickstart

90 seconds to your first run.

### Path 1 — one-liner (recommended)

```bash
curl -fsSL https://atlas-ai.au/install | bash
# installs the skill + prd_taskmaster package
# TaskMaster install is optional — unlocks the TaskMaster backend
```

### Path 2 — Claude Code plugin

```bash
# add the marketplace, then install the plugin
/plugin marketplace add anombyte93/prd-taskmaster
/plugin install prd

# optional — unlocks the TaskMaster backend
npm install -g task-master-ai
```

### First run

Open any project in Claude Code and type:

```
/prd:atlas      (or /prd:go, or just say: "I want to build …")
```

Requires Python 3.11+ and Linux / macOS / WSL. The free engine needs **no paid API key** — it
uses the model CLIs you already have; an optional local research proxy can be plugged in
(bring your own — not bundled). npm installs run a `postinstall` step that pip-installs the
MCP server's Python deps (non-fatal warning if pip is unavailable).

---

## What "verified" means

Most AI coding tools tell you a task is done. This one makes "done" provable:

- **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.
- **A real task graph.** Requirements become backend-neutral `tasks.json` tasks with dependencies, complexity scores, and full subtask coverage — not a flat checklist.
- **Evidence-gated execution.** Each task is implemented and must produce execution evidence before it counts as done.
- **A completion token you can trust.** `SHIP_CHECK_OK` is emitted only when every gate passes — and a single non-zero `Exit status` in any evidence file blocks it. It is structurally hard to fake. (One escape hatch exists for incident recovery: an explicit admin override flag that is audit-logged and marks the token `[OVERRIDE]` on stdout — never silent.)

```
┌─ atlas ── PHASE 3/4: GENERATE ─────────────────────────────┐
│  Grade: GOOD  ▰▰▰▰▰▰▰▰▱▱  49/57 (86%)                      │
│   ✓ 11 checks passed   structure · testability · metrics   │
│   ⚠ 2 warnings   (quoted + located, not just counted)      │
│   ✓ 0 placeholders     (TBD/TODO/{{...}} scan clean)       │
│  Tasks: 14 parsed · 52 subtasks · dependencies mapped      │
└────────────────────────────────────────────────────────────┘
```

---

## Project status

**Pre-alpha.** The deterministic core — graded PRD validation, the task graph, the ship-check
gate, the CLI — is covered by ~300 tests and is the most stable surface. The newer systems
around it (cross-vendor fleet, backend abstraction, the token-economy ledger, the bundled Pro
MCPs) are **recently built and not yet battle-tested**; their numbers (e.g. cost savings) are
verified-rate *estimates*, not measured guarantees (see
[`docs/product/MODEL-ECONOMY.md`](docs/product/MODEL-ECONOMY.md)). Expect breaking changes
between releases; pin a version for stability. Bug reports and use-case notes are the fastest way
to move it toward stable — [open an issue](https://github.com/anombyte93/prd-taskmaster/issues).

## Built for the token-shortage era

Every job runs on the cheapest model that can do it — and escalates only when a validator says
it failed. One setting controls how aggressive that is:

```json
// .atlas-ai/fleet.json
{ "token_economy": "conservative" }   // or "balanced" (default) / "performance"
```

Task decomposition and research run through the selected backend. Native mode works without a
TaskMaster install; installing `task-master-ai >= 0.43.0` unlocks TaskMaster's model-agnostic AI
(any API you configure — Anthropic, OpenAI, Perplexity, Gemini, openai-compatible…) and isolated
workdir expansion when that backend is selected. Complexity 2 scaffolding gets a haiku-class
model; the hardest long-running work gets the frontier model; nothing defaults to expensive.
Local telemetry (`economy-report`) shows your real success-rate and latency per model so the
routing gets smarter on YOUR workload — priors and sources in
[`docs/product/MODEL-ECONOMY.md`](docs/product/MODEL-ECONOMY.md).

## Free vs Atlas Pro

> **Atlas Pro is in private pilot — not generally available and not yet for sale.** Pricing is
> not set. During the pilot, access is granted at our discretion to testers with a strong use
> case (often free). The table shows what Pro *will* add; the Pro-only rows are **experimental and
> not fully tested**. Want in? **[Request pilot access →](https://github.com/anombyte93/prd-taskmaster/discussions)**
> (an on-site signup at `atlas-ai.au/pilot` to be notified at launch is coming).

| | Free (MIT) | Atlas Pro — private pilot |
|---|:---:|
````
