The Greenfield Test: Can You Regrow a System From Cards?

The thesis was simple. Uncomfortably simple.

If intent hardening works, you should be able to write 29 cards, seed them into any capable agent, and regrow a working system from scratch. No engineering heroics. No complex orchestration. Just clear scope, clean success and failure conditions, and one hard rule: only do what is scoped.

We called it the greenfield project. It ran in four phases. Phase 1 was the design. Phase 2 was the build. Phase 3 was the proof. Phase 4 was the hardening. Each phase had one job and one gate.

Phase 1: The Design

29 locked-scope cards plus one index card that holds the map. A spreadsheet. And a prompt that was eleven words long.

Read system rules. Read card XXX. Implement.

That was it. That was the entire operational instruction. Everything else lived in the cards.

Phase 1 was the narrative work — writing the 29 cards, hardening intent before anything was built. Each card defined one component: what it was for, what success looked like, what failure looked like, what it must never do, its MC target, and its dependencies. This was the design work. The seed. Nothing moved to Phase 2 until every card was written and the scope was locked.

The cards covered the full stack across three layers:

• 13 LEGO blocks: Vault, Memory, Ingest, Assembly Line, Cognitive, and the rest of the foundation
• 6 crew agents: Caretaker, Gardener, Mercury, Sentinel, Conductor, Scribe
• 10 core systems: MC engine, North Star, memory system, LEGO registry, API layer, and the systems that held everything together

29 components total. Nothing outside that scope.

Phase 2: The Build

Phase 2 was execution. Taking the cards in dependency order and building. Foundation blocks first, then the layers that depended on them, then the systems at the top. No card opened until the previous gate passed.

The human role was orchestrator and gate — not builder, not debugger.

The same eleven-word prompt was fed into every agent available: Cursor, Claude, GitHub agents, IDE agents. Whatever was accessible with limited resources. The assembly line concept was sequential — nano agents in order, each scoped to its card, each checked at the gate before the next card opened.

One hard rule held throughout: only do what is scoped. Nothing outside the card. Nothing assumed. Nothing invented.

Phase 3: The Proof

Phase 3 was the comparison. Did the system built from cards behave within the bounds defined by those cards? The gates checked four things:

• Sentinel compliance: 20 of 20 checks passed, 100%
• MC separation: gate score versus confidence score, valid with zero violations
• Dependency graph: the LEGO build order, valid with zero circular dependencies
• Project and North Star bounds: valid with zero violations

The assembly line ran end to end. All six stages completed in sequence: Caretaker, Gardener, Mercury, Sentinel, Conductor, Scribe.

One honest note. Two behavioral equivalence checks were marked different, meaning outputs were not byte-identical to a reference comparison. That was expected and it was never the claim. The thesis is bounded outcomes through declared gates, not automation cosplay. The gates passed. The implementation path was intentionally unconstrained. A contractor delivers the product, not the method.

Phase 4: The Hardening

Phase 4 was the hardening analysis. Every component examined for gaps against its MC target. Where were the risks? What needed reinforcement?

Across all 29 components: zero critical priority gaps. Zero high priority gaps. Zero medium priority gaps. The recommendation from the system itself was to focus on refinement and polish.

What Came Out — And What We Deliberately Did Not Claim

24,400 lines of reference backend code came out of that process. 29 components each traceable to its card. 719 files in the evidence manifest. The full greenfield code footprint, including tests, frontends, and scripts, came in at approximately 81,500 lines across 294 files.

We did not pretend the first harvest was a finished product. The system completed 100% of what was scoped. The honest number is that we only scoped roughly 85% of what a finished system needs. The remaining 15% was never in the cards — not missed, not forgotten. It stayed undone because it was never defined, and that is the one hard rule working exactly as designed.

What wiring and review exposed we did not smuggle back into the original scope. We delta-carded it. Named the gap, defined success and failure, and parked it for the next pass. That is how you govern stochastic builders without pretending the first run finished the job.

The best learning moment was not in the build. It was in review. Phase 3 gave us a clean assembly line pass and an honest not-tested on memory integration. The system was wired enough to run, not yet proven enough to trust. Instead of patching quietly we opened a delta card — same contract shape as the original 29: goal, gate, failure mode — and fed the exception back into the loop.

Every fix is a learning point for the human. Therefore a learning point for the AI. The failure mode became a card. The card became tests. The tests hardened the next run. That is not debugging. That is the ML loop running with a human in the gate.

Undefined work stayed undone. Defined work got done. Discovered work got carded, not improvised.

What It Means

In a typical AI-assisted build, the pattern is: prompt, hope, review avalanche. Scope creeps through while-you’re-at-it additions. Success means it runs on someone’s machine. Governance means auditing the pull request at the end.

In greenfield the pattern was: card, gate, next card. Undefined work stayed undone by design. Success was defined as gates you wrote in advance. Governance was intent hardened before the first line of code.

Think of it the way you would a contractor. You specified outcomes and failure modes, not implementation method. The build passed acceptance. You paid for the product, not the method.

Greenfield hardened into Janus V7’s layer model. V7 is the product. Greenfield is the lab notebook. V7 inherited the philosophy — layers, operator surface, intent hardening, gate discipline. It dropped the experiment scaffolding and kept the contractor model.

The prompt was eleven words. The card was everything. That is the point.

Greenfield At a Glance

The cards were the seed. The system was the harvest. The evidence pack is the receipt.

The full greenfield evidence pack — phase results, traceability index, and hardening report — is available on request. Contact via dtm-system.com.