What REI is
What REI Harness is, what problem it solves and why the process matters before the commands.
Source: README.md, docs/product-strategy.md and .rei/docs/
The problem: deciding, planning and executing in the same conversation
When deciding what to build, planning how and making the change all happen in the same conversation, nothing is recorded and nobody can review the decision. AI speeds up writing, but it does not guarantee that the right thing is being built.
Building blind
Code is written before the scope is clear.
Hallucinations
Invented APIs or data presented as fact.
Unauthorized decisions
Architecture or scope changed without approval.
Out-of-bounds actions
Environments and data that should not be touched.
Rework
Code that is fast to write and expensive to fix.
The proposal: specification, human approval and evidence
REI Harness is a Spec Driven Development harness that installs in any repository and coordinates AI agents behind a mandatory human approval gate. It separates deciding, planning and executing, and leaves the trail in the repository itself.
Specification first
The plan exists before the first line of code.
No Work Item moves to implementation without an explicit sign-off; silence is not approval.
Separate roles
Leader, Spec Author, Implementer and Reviewer each have their own contract; the Initializer customizes the project documentation.
Guardrails
Defined scope, mandatory verification and hard rules.
Traceability
Planning, progress, decisions and history live in
.rei/.Living documentation
What the site states can be traced to the repository or to a cited source.
Runtime-agnostic and local-first
The role contract and the CLI are the value; the adapter is optional.
External evidence
Most developers use AI, and many distrust how accurate it is. This site does not make up its own figures: each case links to its source and sticks to what the study shows.
An agent deleted a production database during a code freeze, ran destructive commands without authorization and generated fake data.
The clearest case of why human approval, separate environments and limits on actions are needed.
Randomized study with experienced open source developers: with AI they took 19% longer, although they believed they had been 20% faster.
Perceived productivity is not evidence. You have to measure and verify.
More duplication, more copy/paste, more churn and less refactoring as AI authorship grows.
Speed without design degrades maintainability.
About 45% of code generation tasks introduced a known vulnerability; security does not necessarily improve with larger models.
Review and guardrails are not optional.
AI adoption is associated with higher throughput and lower delivery stability: AI amplifies a system's strengths and weaknesses.
The existing process decides the outcome, not the tool.
84% use or plan to use AI; 46% distrust the accuracy of its results and only 3% highly trust them.
There is demand for verifiable trust, not just for speed.
On a bounded task, the group with Copilot finished 55.8% faster.
AI does speed up specific tasks; the problem is the lack of process.
Product principles
The why before the what
The process and the problem justify the commands.
Human approval is the product
The flow makes the gate visible; it does not hide it.
Documentation is the source of truth
Every claim can be traced.
Showing limits builds trust
The viewer is read-only, GitHub Issues is optional and direct mode has restrictions.
One source per fact and minimal dependencies
Commands, states and roles are defined once.
What REI is not
Not a code generator
Nor an autonomous agent that works on its own.
Not the CLI repository
The code lives in its own repository and this site documents it.
Not the spec viewer
rei viewis local and read-only.Not a control panel
The site does not run commands or modify Work Items.
Not a metrics showcase
No customers, testimonials or figures that cannot be shown.
Who it is for
Individual developer
To stop improvising with the agent without setting up a heavy process.
Reviewer or approver
To see what will be done before it is written, and to be able to reject it.
Team with several runtimes
A shared role contract for OpenCode, Claude Code, Cursor and Codex.
Maintainer
A public reference for commands, states and contracts.
Skeptic
Limits and evidence: what it does and what it does not.
Distinguishing strengths
SDD from minute zero
Code does not start until an approved plan exists.
Mandatory human approval
No Work Item moves to implementation without an explicit decision; silence is not approval.
Explicit, separate roles
Each role has a contract and does not step into another's work.
Guardrails
Defined scope, mandatory verification, diff-based review and hard rules.
Traceability
Planning, progress and decisions stay in the repository, not in the chat.
Living documentation
The source of truth is the repository and it is updated with the work.
Runtime-agnostic
The value is in the role contract and the CLI; the adapter is optional.
Optional GitHub Issues
Issues, branches and PRs are a projection of the work, not the source of truth.
Single binary
One executable with no runtime dependencies.
Local-first
Everything happens on the user's machine and repository; the CLI does not call external services.
Minimal dependencies
The platform and own code before third-party libraries.