From zero to hero — production-ready Python, without the ceremony.
A delivery system that treats documentation as a first-class artifact and enforces production rigor through an AI-assisted workflow. Your team ships features, not broken promises.
You have used AI coding assistants. They generate code fast, but without tests, without traceability, and without review. This template enforces TDD by default: acceptance criteria exist before code, every requirement traces to a test, and an adversarial review gates every shipment. The AI writes tests first, respects your architecture, and ships code you would merge with confidence.
Stakeholders cannot read code. They read decisions. This template turns your repository into a transparent narrative: Gherkin stories trace requirements to tests, architecture decision records preserve reasoning, and a living domain model keeps everyone speaking the same language. Demo from the same source your engineers build from. No drift. No "trust me, it is done."
SCOPE → ARCH → TDD LOOP → VERIFY → ACCEPT
Each feature moves through five steps. At any moment, exactly one feature is in progress — enforced by filesystem state, not convention:
docs/features/backlog/ ← scoped, waiting
docs/features/in-progress/ ← building now (max 1)
docs/features/completed/ ← accepted and shipped
Scope is written before architecture. Architecture is written before code. Code is reviewed adversarially before acceptance. Nothing moves to completed without explicit Product Owner sign-off.
Every artifact is version-controlled alongside the code that implements it.
Feature narratives — Gherkin .feature files in docs/features/ show exactly what is scoped, building, or shipped. Each story maps directly to tests; no requirement is orphaned.
Architecture decisions — Every significant architectural choice is recorded as a dated ADR in docs/adr/. Six months from now, the team can reconstruct not just what was built, but why.
Domain model and glossary — A living domain model and glossary keep business language consistent across team, documentation, and code. No invented synonyms; no drift between what stakeholders say and what engineers build.
System overview — docs/system.md reflects only completed, accepted features. No stale speculation; no documentation that lies about current state.
C4 diagrams — Context and container diagrams generated from the same source as the code, giving stakeholders a precise picture of system boundaries.
Post-mortems — Failures become append-only organizational memory in docs/post-mortem/. The same failure mode does not repeat silently; it leaves a record.
TDD by default — Red → Green → Refactor, one acceptance criterion at a time. Every test is written before the code it validates. The loop is canonical: write the failing test, write the minimum code to pass, then refactor with the safety net of a green bar.
Behavioral tests only — Tests describe observable contracts, not implementation internals. A test that survives a complete internal rewrite is a good test. A test that breaks on refactoring is a liability.
100% coverage — Measured against your package. No untested paths ship. Coverage is a floor, not a goal.
Design principles enforced — YAGNI, KISS, DRY, SOLID, and Object Calisthenics are not guidelines — they are review gates. Every principle is checked with file and line evidence before a feature is approved.
Refactoring as first-class — The REFACTOR phase is not optional cleanup. Code smells trigger specific pattern applications. Complexity is managed continuously, not accumulated and then confronted.
Git workflow with guardrails — All work happens on feature branches. No force push. No history rewrite on shared branches. Conventional commits only. Clean merges to main via --no-ff. The branch model is simple and safe by default.
Zero type errors — Full static type checking with no exceptions, no type: ignore suppressions.
Adversarial verification — The architect who designed the system reviews it. The default hypothesis is "broken." Green automated checks are necessary but not sufficient for approval.
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 reportMIT — see LICENSE.
Author: @nullhack · Documentation