Specs as Source Code

Prose plus an AI swarm, compiled into working software

The dare

StrongDM handed the industry buildable prose — and shipped no code

StrongDM's Attractor repo is a "software factory" README plus three natural-language specs (nlspecs): human-readable prose meant to be used directly by coding agents to build an AI workflow platform.

Their README frames the goal plainly — and the repo itself is the proof of the dare.

An NLSpec is "a human-readable spec intended to be directly usable by coding agents to implement/validate behavior."
README line 3: build your own Attractor "to create your own software factory."
Both obra/attractor and strongdm/attractor carry the identical description and identical 5-file tree.

The proof

The spec repo ships ZERO code — only prose, in all of git history

GitHub's language map for both repos returns {}. Across the entire git history, the only files ever added are three specs, a README, and a LICENSE.

So the dare is real — but does prose alone actually prove anything?

0

code files ever committed

5

tracked files total (3 specs + README + LICENSE)

3

natural-language specs published

The complication

~5,687 lines of prose still prove nothing until someone builds them

Each of the three specs carries a "Definition of Done" section — written to be usable directly as source input. But a spec with no implementation is just a promise. The story needs a compiler.

So someone had to actually feed the prose to a machine and see if it ran.

5,687

spec lines of prose across three files

~34,800

words of specification

3 / 3

specs with a "Definition of Done"

The compiler

Sam Lee fed the three specs to Amplifier's multi-model swarm

Samuel Lee (samueljklee) handed the prose to Amplifier and pointed a Claude / GPT / Gemini swarm at it — authoring 145 of 146 commits on samueljklee/attractor, a Python project implementing the StrongDM nlspec.

The interesting part is HOW that swarm turned prose into trustworthy code.

145 / 146

commits authored by Sam Lee

3

model families in the swarm: Claude, GPT, Gemini

Python

primary language of the implementation

How it hardened

The models peer-reviewed each other and caught bugs no single model saw

Across 27+ swarm review rounds at the build snapshot, different models found each other's defects — genuinely multi-provider, with adapters for Anthropic, OpenAI, and Gemini.

Cross-model review is how the prose became code you could trust — and it came out as real architecture.

Opus 4.6 found a DOT injection-to-execution chain Sonnet and Gemini both missed.
Gemini found a parallel context deepcopy race.
GPT O3 found an apply_patch hunk-overlap corruption bug.

The turn

The prose came out as real architecture — three layers matching the specs

The specs didn't just parse; they mapped 1:1 onto a running structure. The implementation is organized as the three spec layers, plus an HTTP server.

And at the build snapshot, that structure was already tested and green.

Layer 1 — Unified LLM Client (attractor_llm)
Layer 2 — Coding Agent Loop (attractor_agent)
Layer 3 — Pipeline Engine (attractor_pipeline)
Plus an HTTP server (attractor_server)

The compile happened

At commit 9f7a846 the prose was working, tested software

At the build snapshot (commit 9f7a846, 2026-02-12), the swarm reported ~90% coverage of the three specs, all three layers built, with 303 unit tests and 8 real-API E2E tests green.

Prose plus a swarm compiled into a verified implementation — so what does that change?

~90%

of the three nlspecs covered (self-reported)

303

unit tests at the 9f7a846 snapshot

8

real-API E2E integration tests

What you keep

If prose plus a swarm compiles into tested software, the spec is the source

StrongDM wrote the prose and shipped no code; Sam Lee's Amplifier swarm turned ~5,687 lines of specification into a running, tested Python system. The natural-language spec was treated as source — and writing it is the real engineering.

Sources

Research Methodology

Data as of: 2026-07-21 (independently re-verified against ground truth)

Feature status: nlspec repo complete as prose (0 code files); Sam Lee's implementation Active (last push 2026-03-05).

Primary sources: obra/attractor (mirror of strongdm/attractor, the nlspec repo); samueljklee/attractor (the Amplifier-built implementation).

Commands run:

Zero-code check: gh api repos/obra/attractor/languages & strongdm/attractor (both return {}); git log --all --diff-filter=A --name-only
Spec size: wc -l *.md & wc -w *.md (5,687 lines / ~34,792 words)
Definition of Done: grep -c 'Definition of Done' *.md (3/3 specs)
Software-factory framing: git grep -in 'software factory' README.md
Authorship: git log --format='%an <%ae>' | sort | uniq -c (145/146 Sam Lee)
Build snapshot: git show 9f7a846:README.md | grep -niE '303|E2E integration|90%|27+'
Layers & providers: ls src/; ls src/attractor_agent/profiles/

Gaps / qualifiers: "303 unit tests", "8 E2E tests", "~90%", and "27+ swarm review rounds" are the figures at commit 9f7a846 (2026-02-12); the repo later grew (README HEAD cites 432 unit tests, 35+ review rounds). "~90%" is self-reported; a separate microsoft gap analysis rates it strongest for the Pipeline layer (~90%), lower for Unified LLM Client (~41%). Live-API results were not re-run, only the reported counts verified.

Primary contributors: Samuel Lee (samueljklee) — 145/146 commits on the implementation; StrongDM — published the three specs; Brian Krabach — 1 commit on Sam's repo.