create · autonomous development
create is the delivery capability. Twelve specialized agents plan, build, test, and review code. You set direction and approve at the gates. Everything else runs.
Every session starts the same way.
How it works
Every feature follows the same five-phase sequence. Gates are mechanical: a phase does not close until the criteria pass. No exceptions.
Alex writes the ADR and Bea scopes the work. Acceptance criteria exist before a line of code does.
Tessa's tests define the target. Bob writes the code to pass them, and nothing more.
The 700-test suite runs. The gate stays red until every test passes. No workarounds, no waivers.
Lint, eval, and Quinn review before anything closes. Sentinel checks for security violations.
Stewart closes the ticket and commits the work. You sequence what comes next off the backlog.
Nothing moves to the next phase until the gate passes. Nothing reaches done without clearing all five.
The roster
Every agent has a bounded role and a defined authority ceiling. No agent approves its own work, claims outside its role, or skips review. The names are a shorthand for keeping the wheel: a ticket to Bob means build, to Quinn means review.
Writes the ADR. Decides the shape of the work before it starts.
Turns intent into scoped tickets with verifiable acceptance criteria.
Writes the code to pass the tests. Nothing speculative, nothing extra.
Writes tests first. The suite is the target the build aims at.
Reviews every change before it can close. Reuse, clarity, correctness.
Audits for vulnerabilities and policy violations at the review gate.
Assesses whether work is actually complete, not just present.
Reproduces, isolates, and fixes. Tracks down what broke and why.
Improves structure without changing behavior, under green tests.
Documents and publishes. Keeps the record legible to the next agent.
Triages, sequences, commits, and closes. Keeps the backlog honest.
Routes work to the right specialist. For now, you keep the wheel.
Set in order, struck once
How it holds together
Software projects fail the same three ways: scope drift, knowledge lost at handoffs, and slow velocity despite good tooling. These four constraints are a direct response to all three.
Constraint 01
Ticket to ship, nothing skipped
create is the delivery engine. Tickets move through defined states with mechanical gates at every transition. No manual approvals, no social pressure. Ghost tickets and stale claims are structurally impossible because the schema enforces what process cannot.
Constraint 02
700+ tests. The gate doesn't negotiate.
Tests are written before code. RED to GREEN to REFACTOR, enforced by a suite that exceeds 700 tests and runs on every cycle. The gate will not open on a red suite for velocity, for deadlines, or for anyone. Validation spans every language the stack touches: TypeScript, Python, and Rust. One pipeline, consistent enforcement.
Constraint 03
Institutional knowledge doesn't reset
Session scratchpads, decision traces, and phase handoffs persist across context limits through remember, the Lexenne memory layer. Agents do not start cold. The system accumulates context across every session and handoff, closing the knowledge gap that breaks projects at scale.
Constraint 04
Agents handle mechanics. You decide what matters.
The repetitive mechanics of delivery, writing tests, sequencing the backlog, reviewing code, are automated. The decisions that actually matter stay with you. The automation is the point, and the human in the loop is by design, not by limitation.
Coming
The pipeline runs when you hand it a ticket. A Loop is the next layer: a long-running agent that watches the system, finds work worth doing, and brings it back through the same gates. Every Loop runs on five moves, and earns autonomy one rung at a time, from notify, to propose, to act.
Evelyn watches the pipeline and asks the hard question every gate avoids: is this actually done, or does it just look done? The skeptic that says no is the move we are most careful to get right before it earns authority.
Doug goes looking for the work nobody filed: the stale dependency, the flaky test, the quiet regression. He runs discovery on his own schedule and proposes a fix as a ticket, never commits one unattended.
A Loop only climbs to act once it has earned trust at notify and propose. That is the whole design.
The pair
create reads its context from remember and writes every decision back. Explore the memory it runs on, or reach out about putting create to work in your own development.