agent-ready-repo

# agent-ready-repo

**The supervised AI operating model for software teams.**

```
Raw idea → Gate: Idea → Spec → Gate: Spec → Shipped code → Gate: PR → Production
```

[![PyPI](https://img.shields.io/pypi/v/agentbundle)](https://pypi.org/project/agentbundle/) [![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue)](#license) [![OWASP Agentic Skills Top 10](https://img.shields.io/badge/OWASP-Agentic%20Skills%20Top%2010%20v1.0-blue)](https://owasp.org/www-project-agentic-skills-top-10/)

[Quick Start](#quick-start) · [The Three Loops](#the-three-loops) · [The Catalogue](#the-catalogue) · [Docs](docs/guides/) · [Contributing](CONTRIBUTING.md)

> "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents." — [Peter Steinberger](https://x.com/steipete/status/2063697162748260627)

Agent coding tools moved the leverage from the prompt to the loop. But an unattended loop also makes unattended mistakes — and it will self-certify its way out of every check you give it. The answer is a supervised loop with mechanical gates the agent cannot bypass.

Three peer loops span the full SDLC. Discovery takes a raw idea to a ratified brief. The build loop runs spec to shipped code with hard gates and cold-read reviewers. The release loop validates the deployed whole before any human touches a prod switch. Human gates sit at every irreversible handoff; nothing runs past them automatically.

`core` is the flagship pack — the build loop, in one command:

```bash
pip install agentbundle
agentbundle install --pack core
```

## Quick start

**Install via Claude Code / Claude Desktop** (no extra tooling required):

```bash
# Install any pack directly — no CLI to set up
claude plugin install https://github.com/eugenelim/agent-ready-repo/tree/claude-plugins-dist/core

# Browse all available packs with install commands
# → https://eugenelim.github.io/agent-ready-repo/plugins/
```

**Or install via agentbundle CLI** (supports all agent adapters):

```bash
# Install the CLI (one-time)
pip install agentbundle

# See the catalogue
agentbundle list-packs

# See what you have installed — version + whether an upgrade is available
agentbundle list-installed

# Install the flagship loop into this repo
agentbundle install --pack core

# Install a pack at user scope — follows you across every project
agentbundle install --pack research --scope user

# Install a whole curated profile in one command
agentbundle install --profile solution-architect

# Upgrade a pack to the catalogue's version (asks before writing; --yes for CI)
agentbundle upgrade --pack core

# Preview any install without writing a file
agentbundle install --pack core --dry-run
```

`--dry-run` previews every file before anything is written — one line per file, then a `create`/`overwrite` count. Installs auto-detect your agent and fall back to Claude Code; [configure a different default →](docs/guides/_shared/how-to/configure-adapter.md)

Every source verb defaults to this catalogue when you don't name one; pass a git URL or local path to use a different one, or `agentbundle config set source <catalogue>` to change the default.

**Machine-readable catalogue:** `https://raw.githubusercontent.com/eugenelim/agent-ready-repo/claude-plugins-dist/marketplace.json`

## The three loops

```
product-engineering              core                    release-engineering
───────────────────              ────                    ───────────────────
discovery-lead                   work-loop               release-lead
Raw idea → Brief  ─Gate: Idea─▶  Spec → Shipped code  ─Gate: PR─▶  Production
```

Each loop is autonomous where the work is reversible and surfaces to a human at every irreversible step.

### Discovery — `product-engineering`

Raw idea → ratified brief. Five candidate shapes explored in parallel, collapsed through product, UX, architecture, and safety lenses.

**Human gate.** You approve a ratified decision brief, not a validated solution. The loop never advances past Gate: Idea automatically.

→ [Discovery loop guide](docs/guides/product-engineering/) · [Walk a discovery end-to-end](docs/guides/product-engineering/tutorials/walk-a-discovery-end-to-end.md)

### Build — `core`

Spec → shipped code. Lint, typecheck, and tests must pass. Three specialist reviewers each read the diff cold, in a fresh session — adversarial by design. Gate: Spec sits between the approved spec and the first line of implementation.

**Human gate.** You merge only when adversarial review is clean and all gates pass.

→ [The `core` pack as a system](docs/guides/core/explanation/core-pack.md)

### Release — `release-engineering`

Built → production. Autonomous e2e convergence on ephemeral environments; deployed findings feed back to the build loop automatically.

**Human gate.** Prod ship always surfaces to a human. Always.

→ [Release loop guide](docs/guides/release-engineering/) · [The release loop explained](docs/guides/release-engineering/expla

... (truncated)