The Garden

Plant a seed, harvest a reviewed PR

The reframe

AI can already write the code — the hard part left is the interface

Once a machine can turn a spec into working software, the open question is no longer "can AI code?" It is how a human expresses intent, watches it happen, and stays in control of the machine that writes it.

First, the evidence that the coding really is solved.

The premise, proven

The coding really is solved — this is a platform, not a mockup

amplifier-resolve is an autonomous platform that takes a specification and hands back working software. Its scale shows it is exercised, not hypothetical.

So if code is handled — what is still missing?

24,007

lines of Python in src

3,840

test functions across 184 test files

100

commits, primarily by Brian Krabach (97)

The unsolved gap

Automating the code doesn't answer how a human stays in control

Generating software is one thing. Expressing what you want, watching progress as it happens, and keeping control at every step is a different, still-open problem — and it is the one that matters once the code writes itself.

The Garden is a working experiment aimed exactly at that gap.

Meet The Garden

Plant a seed — describe what you want — and a reviewed PR grows

The Garden is an experimental interface built on amplifier-resolve. You plant a seed — describe what you want as a brief — and a reviewed pull request grows back. You never touch the code.

Feature status: Early exploration / MVP

Under that one gesture runs a real, staged pipeline.

How the seed becomes a PR

A literal five-stage pipeline that ends by opening a pull request

amplifier-resolve's brief-attractor recipe is organized as five named stages. The final stage doesn't write a report — it creates a branch and opens a PR for you to review and merge.

And control over that run is real, not cosmetic.

1

Seed

intent becomes a spec

2

Scenario-generation

behavioral scenarios.json

3

Scaffold

code written blind to scenarios

4

Factory

agent-as-judge convergence loop

5

Deliver

git push → create-pr → pr_url.txt

Control is real, not cosmetic

Each run is isolated, streams live state, and can pause at a human gate

Every unit of work runs in its own isolated worker container. Instances stream live events, and any run can pause at a human gate and resume the moment you respond.

Put those pieces together and you get the seed-to-PR moment.

One container per instance

Each instance runs in an isolated Docker worker container that executes its strategy.

Live state over SSE

Instances stream events as a text/event-stream across 8 lifecycle statuses.

Human gate: awaiting_input

A blocked pipeline transitions to awaiting_input and returns to running when you respond.

The seed-to-PR moment

Tests written first, code converged against them, a PR handed to you

Scenarios are generated from the spec as a holdout set — the scaffolder is forbidden from seeing them. Code iterates in an agent-as-judge loop until it converges, then a branch and PR grow. You review and merge; you never touch the code.

That is the interface working end to end.

A

Tests as a holdout

scaffolder blocked from the scenarios

B

Converge

loop while converged != true, default target 1.0

C

Deliver a PR

branch brief-<task_id> → PR to merge

The pattern to keep

When the machine writes the code, the win is how a human talks to it

The point isn't the AI writing code — that's the solved part. The frontier is the human–AI interface: designing the right way for a person to express intent, watch it happen, and stay in control. That is the problem worth solving.

The Garden is one early experiment aimed straight at it.

Sources

Research Methodology

Data as of: Local amplifier-resolve checkout, HEAD d4eb669 (commit dates 2026-04-29 – 2026-05-20).

Feature status: amplifier-resolve pipeline SHIPPED / VERIFIED; The Garden as a named product is Early exploration / MVP.

Repos: microsoft/amplifier-resolve, microsoft/amplifier-bundle-context-intelligence (the deck's "CXDB", renamed CI in code).

Commands run:

grep -n 'name: "' src/amplifier_resolve/recipes/brief-attractor.yaml — 5 stages (lines 73/212/305/409/438)
sed -n '438,520p' …/brief-attractor.yaml — DELIVER: git checkout -b / push / create-pr → pr_url.txt
find src -name '*.py' | xargs wc -l | tail -1 — 24,007 total
grep -rn 'def test_' tests/ | wc -l = 3,840; find tests -name '*.py' | wc -l = 184
git rev-list --count --all = 100; git shortlog -sne HEAD — Brian Krabach 97, dependabot[bot] 2, Salil Das 1
sed -n '11,30p' src/amplifier_resolve/models.py; grep -n 'text/event-stream' …/routes/broker.py — 8 statuses incl. awaiting_input, SSE

Gaps: No standalone repo named "the-garden" or "issues-to-brief" was found under /home/ramparte/dev/ANext; "The Garden" is the deck's framing over amplifier-resolve. Default iteration count is configurable (recipe default 5, while-cap 10, example brief 3), so no single number is stated as THE count.

Primary contributor: Brian Krabach (97 of 100 commits, local checkout).