From zero to hero — production-ready Python, without the ceremony.
You have tried to ship features with AI assistants. The agent writes code, you review it, and somehow the spec still drifts from the implementation. Tests pass but the feature doesn't match what stakeholders asked for. Architecture decisions vanish into commit messages nobody reads. The review cycle is a black box — either everything passes or nothing does, with no structured progression.
temple8 replaces ad-hoc agent orchestration with state machines that route every step through the right agent with the right skills at the right time.
Flow definitions in YAML declare what happens at each state: who owns it, what they may read, what they must produce, and which conditions gate the next transition. No agent guesses what to do next. No step is skipped. No artifact is written outside its contract.
You write BDD scenarios from stakeholder interviews. Tests are linked to feature specs with @id tags. Every Given/When/Then maps to a test function. No orphan tests, no missing tests. Red-green-refactor cycles are enforced — you can't skip to implementation.
Feature files are the contract. Acceptance criteria are BDD scenarios, not bullet points in a ticket. The delivery flow tracks whether a feature is BASELINED, ACCEPTED, or rejected — with evidence at every gate. You see exactly what was built and why.
Three-tier review: design alignment (does it match the domain model?), structure (coverage, traceability, coupling), conventions (formatting, naming, lint). Each tier can fail independently. No rubber-stamping through one monolithic gate.
flowr check → inspect a state's owner, skills, and transitions
flowr next → see which transitions pass given your evidence
flowr transition → advance to the next state with evidence
State machines route the work. YAML flows define the delivery pipeline — discovery, architecture, planning, TDD cycles, review gates, delivery. Each state declares an owner, skills, input/output artifacts, and guard conditions. The engine validates transitions. The agent executes.
Agents execute it. Each state's owner dispatches to the right agent (PO, SE, SA, DE, R). Skills are loaded per state. Input/output contracts prevent scope creep. Evidence gates prevent premature transitions.
Branch discipline is explicit. Every state declares git: main or git: feature. Project-phase work commits to main. Feature work commits to a feature branch. No ambiguity about where changes belong.
git clone https://github.com/nullhack/temple8
cd temple8
curl -LsSf https://astral.sh/uv/install.sh | sh # skip if uv is already installed
uv sync --all-extras
opencode && @setup-project # personalise for your project
uv run task test && uv run task lint && uv run task static-checkuv run task test # full suite + coverage
uv run task test-fast # fast, no coverage (use during TDD loop)
uv run task lint # ruff format + check
uv run task static-check # pyright type checking
uv run task run # run the app
uv run task doc-build # build API docs + coverage report- Product Definition — product boundaries, users, and scope
- System Overview — architecture, domain model, module structure, and constraints
- Glossary — living domain glossary
MIT — see LICENSE.
Author: @nullhack · Documentation