When this skill is activated, always start your first response with the 🧢 emoji.
Absolute-Human: AI-Native Development Lifecycle
Absolute-Human is a development lifecycle built from the ground up for AI agents. Traditional methods like Agile, Waterfall, and TDD were designed around human constraints - limited parallelism, context switching costs, communication overhead, and meetings. AI agents have none of these constraints. Absolute-Human exploits this by decomposing work into dependency-graphed sub-tasks, executing independent tasks in parallel waves, enforcing TDD verification at every step, and tracking everything on a persistent board that survives across sessions.
The model has 7 phases: INTAKE - DECOMPOSE - DISCOVER - PLAN - EXECUTE - VERIFY - CONVERGE.
Activation Banner
At the very start of every Absolute-Human invocation, before any other output, display this ASCII art banner:
███████╗██╗ ██╗██████╗ ███████╗██████╗ ██╗ ██╗██╗ ██╗███╗ ███╗ █████╗ ███╗ ██╗
██╔════╝██║ ██║██╔══██╗██╔════╝██╔══██╗██║ ██║██║ ██║████╗ ████║██╔══██╗████╗ ██║
███████╗██║ ██║██████╔╝█████╗ ██████╔╝███████║██║ ██║██╔████╔██║███████║██╔██╗ ██║
╚════██║██║ ██║██╔═══╝ ██╔══╝ ██╔══██╗██╔══██║██║ ██║██║╚██╔╝██║██╔══██║██║╚██╗██║
███████║╚██████╔╝██║ ███████╗██║ ██║██║ ██║╚██████╔╝██║ ╚═╝ ██║██║ ██║██║ ╚████║
╚══════╝ ╚═════╝ ╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝This banner is mandatory. It signals to the user that Absolute-Human mode is active.
Activation Protocol
Immediately after displaying the banner, enter plan mode before doing anything else:
- On platforms with native plan mode (e.g., Claude Code's
EnterPlanMode, Gemini CLI's planning mode): invoke the native plan mode mechanism immediately. - On platforms without native plan mode: simulate plan mode by completing all planning phases (INTAKE through PLAN) in full before making any code changes. Present the complete plan to the user for explicit approval before proceeding to EXECUTE.
This ensures that every Absolute-Human invocation begins with structured thinking. The first four phases (INTAKE, DECOMPOSE, DISCOVER, PLAN) are inherently planning work - no files should be created or modified until the user has approved the plan and execution begins in Phase 5.
Session Resume Protocol
When Absolute-Human is invoked and a .absolute-human/board.md already exists in the project root:
- Detect: Read the existing board and determine its status (
in-progress,blocked,completed) - Display: Print a compact status summary showing completed/in-progress/blocked/remaining tasks
- Resume: Pick up from the last incomplete wave - do NOT restart from INTAKE
- Reconcile: If the codebase has changed since the last session (e.g., manual edits, other commits), run a quick diff check against the board's expected state and flag any conflicts before resuming
If the board is marked completed, ask the user whether to start a new Absolute-Human session (archive the old board to .absolute-human/archive/) or review the completed work.
For intentional context resets during long-running sessions (3+ waves completed or context window pressure), see references/context-reset-protocol.md.
Never blow away an existing board without explicit user confirmation.
Codebase Convention Detection
Before INTAKE begins, automatically detect the project's conventions by scanning for key files. This grounds all subsequent phases in reality rather than assumptions.
Auto-detect Checklist
| Signal | Files to Check | |---|---| | Package manager | package-lock.json (npm), yarn.lock (yarn), pnpm-lock.yaml (pnpm), bun.lockb (bun), Cargo.lock (cargo), go.sum (go) | | Language/Runtime | tsconfig.json (TypeScript), pyproject.toml / setup.py (Python), go.mod (Go), Cargo.toml (Rust) | | Test runner | jest.config., vitest.config., pytest.ini, .mocharc., test directory patterns | | Linter/Formatter | .eslintrc., eslint.config., .prettierrc., ruff.toml, .golangci.yml | | Build system | Makefile, webpack.config., vite.config., next.config.*, turbo.json | | CI/CD | .github/workflows/, .gitlab-ci.yml, Jenkinsfile | | Available scripts | scripts section of package.json, Makefile targets | | Directory conventions | src/, lib/, app/, tests/, __tests__/, spec/ | | Codedocs | docs/.codedocs.json, documentation/.codedocs.json, or any .codedocs.json in the repo |
Codedocs Detection
If a .codedocs.json manifest is found, the repo has structured codedocs output. Record its location on the board and set a flag codedocs_available: true. This changes how DISCOVER and PLAN operate - see those phases for details.
When codedocs is available, read docs/OVERVIEW.md and docs/GETTING_STARTED.md immediately during convention detection and append their key facts (tech stack, module map, entry points, dev commands) to the ## Project Conventions section of the board. This front-loads context that would otherwise require separate codebase exploration in DISCOVER.
Output
Write the detected conventions to the board under a ## Project Conventions section. Reference these conventions in every subsequent phase - particularly PLAN and the Mandatory Tail Tasks verification step.
When to Use This Skill
Use Absolute-Human when:
- Multi-step feature development touching 3+ files or components
- User says "build this end-to-end" or "plan and execute this"
- User says "break this into tasks" or "sprint plan this"
- Any task requiring planning + implementation + verification
- Greenfield projects, major refactors, or migrations
- Complex bug fixes that span multiple systems
Do NOT use Absolute-Human when:
- Single-file bug fixes or typo corrections
- Quick questions or code explanations
- Tasks the user wants to do manually with your guidance
- Pure research or exploration tasks
Key Principles
1. Dependency-First Decomposition
Every task is a node in a directed acyclic graph (DAG), not a flat list. Dependencies between tasks are explicit. This prevents merge conflicts, ordering bugs, and wasted work.
2. Wave-Based Parallelism
Tasks at the same depth in the dependency graph form a "wave". All tasks in a wave execute simultaneously via parallel agents. Waves execute in serial order. This maximizes throughput while respecting dependencies.
3. Test-First Verification
Every sub-task writes tests before implementation. A task is only "done" when its tests pass. No exceptions for "simple" changes - tests are the proof of correctness.
4. Persistent State
All progress is tracked in .absolute-human/board.md in the project root. This file survives across sessions, enabling resume, audit, and handoff. The user chooses during INTAKE whether the board is git-tracked or gitignored.
5. Interactive Intake
Never assume. Scale questioning depth to task complexity - simple tasks get 3 questions, complex ones get 8-10. Extract requirements, constraints, and success criteria before writing a single line of code.
Core Concepts
The 7 Phases
INTAKE --> DECOMPOSE --> DISCOVER --> PLAN --> EXECUTE --> VERIFY --> CONVERGE
| | | | | | |
| gather | build DAG | research | detail | parallel | test + | merge +
| context | + waves | per task | per task| waves | verify | closeTask Graph
A directed acyclic graph (DAG) where each node is a sub-task and edges represent dependencies. Tasks with no unresolved dependencies can execute in parallel. See references/dependency-graph-patterns.md.
Execution Waves
Groups of independent tasks assigned to the same depth level in the DAG. Wave 1 runs first (all tasks in parallel), then Wave 2 (all tasks in