zero-review

Zero Review — Auto-Dev Platform

An agent-majority software organization in a plugin. Humans supply requirements and intervene at key decision points. Agents handle everything else — building, testing, triaging — through structured skills that make each role produce high-quality output in one go, without standing human review.

How the Loop Works

Human Sponsor
    │ requirements
    ▼
┌─────────┐    structured spec    ┌──────────┐
│ auto-req │ ──────────────────► │ auto-dev  │
└─────────┘                       └────┬─────┘
                                       │ artifact
                                       ▼
                                 ┌──────────┐
                                 │ auto-test│
                                 └────┬─────┘
                                      │ issues
                                      ▼
                                ┌───────────┐    work items    ┌──────────┐
                                │auto-triage│ ────────────────►│ auto-dev │
                                └───────────┘                  └──────────┘
                                                                    │
                                                                    ▼
                                                                 (loop)

1. The human sponsor states what they want. auto-req turns it into a structured spec.
2. A dev agent picks up the spec, classifies the task, follows the matching paradigm, and ships verified code.
3. A user agent provisions the built artifact in Docker, adopts a persona, uses the software, and files bugs and feature requests.
4. A triage agent deduplicates, classifies, and prioritizes those issues into work items.
5. Work items flow back to dev agents. The loop repeats.

The human re-enters at escalation points: ambiguous requirements, conflicting priorities, policy decisions, or repeated quality gate failures.

This plugin defines the skills and contracts for that loop. It does not orchestrate it — an external system (or a coordinator agent in a separate repo) handles spawning, polling, and state management.

Roles

Each role is a directory with SOUL.md (identity and behavioral posture) and AGENTS.md (operational protocol and interfaces), following the Hermes/OpenClaw convention. USER.md at the repo root describes the human sponsor.

Role	Skill	What they do	Defined in
Human sponsor	—	States requirements, answers escalations, sets priority	USER.md
Req agent	auto-req	Elicits, structures, and validates requirements from vague input	roles/req-agent/
Dev agent	auto-dev	Classifies tasks, follows paradigms, ships verified code	roles/dev-agent/
User agent	auto-test	Exercises software as a simulated end user, files feedback	roles/user-agent/
Triage agent	auto-triage	Deduplicates, classifies, prioritizes, dispatches work items	roles/triage-agent/

Skills

auto-dev uses software engineering discipline and test-driven verification to make coding agents produce high-quality code in one go, without human review or intervention. Every task goes through a mandatory design-thinking phase (architecture for greenfield, impact analysis for enhancements, hypothesis-driven diagnosis for bugs) before any code is written. This forces the agent to understand the problem deeply enough to get it right the first time. Test-plan-driven development (TPDD) defines what "correct" means before implementation — Must Have checkpoints, integration boundaries, and Forbidden Zone redlines give the agent concrete, verifiable success criteria it can check autonomously. Quality gates at every phase boundary replace the human reviewer: the agent self-assesses against objective criteria and escalates only when something doesn't fit. The result is code that passes its own review — designed, implemented, reviewed, and verified — delivered without the human ever needing to read a line.

auto-test makes user agents exercise software the way real people do, not the way engineers verify it. It provisions a Docker environment with the right interaction toolkit (Playwright for web, shell for CLI, HTTP client for APIs), assigns the agent a persona with specific goals and patience limits, and runs a perception-action loop — observe the screen, decide what to do, act, record what happened. Friction is signal: confusion, slowness, missing affordances, and broken flows all become structured bug reports and feature requests that a dev agent can act on without asking for clarification. The persona system prevents the agent from over-testing: a novice gives up when confused, a power user pushes through, an adversarial tester probes boundaries.