Your AI writes fast. Temper makes it last.
An intent-gated SDLC for AI-generated code — every gate verdict computed by a small CLI, never asserted by a model.
/plugin marketplace add galando/temper
/plugin install temperThat's it. Your first /temper "…" sets the project up — config, scaffold, and the
native commit gate that physically blocks git commit while any gate is red.
AI writes code fast, but with structural failure patterns: happy paths without edge cases, features nobody asked for, calls to methods that don't exist, correct code never wired in. Most tools check whether the code compiles. Temper checks whether it solves the right problem — mechanically, not by asking the model to grade itself.
One loop, a human gate at every stage, the cheapest artifact reviewed first:
INTENT → PLAN → DESIGN? → BUILD → REVIEW → CHECK → COMMIT
↑ WHY — approved before any tokens are spent downstream
- Intent gate first — you approve the Problem and success criteria before exploration or architecture runs. A wrong intent multiplies into wrong everything; correcting it at this gate costs words, after Plan it costs the plan.
- Scenarios before architecture — BDD scenarios are derived from a measured blast radius, so every planned file traces to a behavior. That's the structural defense against over-engineering.
- Every gate is computed —
scripts/temper(auditable bash, no network) reads an evidence ledger (temper evidence add/run) and prints PASS/FAIL per requirement. A red gate blocksgit commitvia a real pre-commit hook; a human can override (recorded with their identity, never erased) — a confused model can't. - The loop closes itself —
temper bandswatches metric history with control bands (pure arithmetic, no model); a breach is drafted as the next intent and rides the same pipeline. Fixes write a committedlessons.mdevery future RCA reads first.
Proof it catches real bugs: three seeded-defect fixtures run through the live pipeline in CI and must mechanically FAIL naming the defect — evals/README.md, evidence gallery.
Three you'll actually type — /temper runs and routes the rest:
| Command | Purpose |
|---|---|
/temper "…" |
The whole pipeline, intent gate to commit |
/temper:fix "…" |
Root cause → failing test (write-protected) → minimal fix |
/temper:intent "…" |
Capture an idea as a committed draft, build it later |
Granular control — each stage on its own, plus utilities
| Command | Purpose |
|---|---|
/temper:plan |
Blast radius + BDD scenarios + architecture |
/temper:design |
System design, Areas of Concern gated |
/temper:build |
Scenario-driven TDD + coverage gate |
/temper:review |
Confidence-scored review + intent validation |
/temper:check |
Stack-aware validation pipeline |
/temper:status |
Dashboard: gates, hotspots, control bands |
/temper:pack |
Manage quality packs |
/temper:init |
Explicit setup (idempotent) |
Autonomy (opt-in): after you approve the plan, /temper can run the remaining
stages unattended — checkpointing each green stage, parking before commit. It never
commits, pushes, or merges.
Quality packs: versioned policy (security, TDD, quality, performance, api-design, architecture-depth) enforced during build and review, with deterministic hook backstops for the rules that must always hold. docs/packs.md
Works with any CI: temper ships no platform files — its automation surface is
commands and exit codes (temper bands, temper gate review, temper metrics append), the same under GitHub Actions, GitLab, Jenkins, or cron.
examples/workflow/README.md
Markdown plus ~1,500 lines of auditable shell. No network calls, no telemetry; writes
stay in your project (.claude/temper.config, .temper/). The committed artifact
chain — intent, plan, design, gate ledger, diff — is the audit trail: who asked, what
was planned, what the gates verified, in the same commits as the code.
- Getting Started · Commands · Packs
- Methodology — IDD + BDD + TDD, one contract file
- AI-Native SDLC Alignment — temper vs Anthropic's playbook, play by play
- Recommended Setup · Enterprise · Privacy
CONTRIBUTING.md · MIT © Gal Naor