Case Study

Attractor
NL Specs to Working Software

StrongDM published three natural language specifications for an AI workflow platform. They shipped zero code. Sam handed the specs to Amplifier and built the entire thing.

Sam Lee | Amplifier | 2025

The Gauntlet

The Software Factory
Moment

"Code must not be written by humans.
Code must not be reviewed by humans."

Justin McCarthy, CTO — StrongDM

StrongDM published a manifesto on "Software Factories" — non-interactive development where specs and scenarios drive agents that write code
They released three natural language specifications describing a full 3-layer AI workflow platform
They shipped zero implementation — just the specs. The gauntlet was thrown.

Concept

Natural Language Specs

Software specifications written in natural language, not code. Detailed enough for an AI to implement from scratch. Design docs become source code input.

3

Attractor Pipeline Engine

DOT-graph orchestrator that chains LLM calls into multi-stage workflows

2

Coding Agent Loop

Autonomous agentic loop pairing LLMs with developer tools

1

Unified LLM Client

Single interface across OpenAI, Anthropic, and Google Gemini

Source: github.com/strongdm/attractor

Origin

How It Started

Clone repo

→

Feed to Amplifier

→

Read all 3 specs

→

Build layer by layer

Sam cloned StrongDM's attractor repo — specs only, no code
Handed the repo link to Amplifier
Amplifier read all three specifications cover to cover
Then built it — spec section by spec section

Multi-Provider Swarm

Claude, GPT, and Gemini all participating in the build process — not just one model, but the full ensemble reviewing and implementing together.

Claude

GPT

Gemini

Core Concept

Graphs as Recipes

Workflows defined as Graphviz DOT files. Each node is a task. Each edge is flow. You can literally see your workflow.

digraph Pipeline {
    graph [goal="Build a REST API"]

    start     [shape=ellipse]
    plan      [shape=box,
                prompt="Create a plan for: $goal"]
    implement [shape=box,
                prompt="Write the code for: $goal"]
    review    [shape=diamond]
    done      [shape=Msquare]

    start -> plan -> implement -> review
    review -> done      [condition="success"]
    review -> implement [condition="fail"]
}

Node Shapes = Behavior

◯ ellipse Start node

▢ box LLM call

◆ diamond Conditional

⛨ house Human gate

[M] Msquare Exit node

⇄ edge Flow + condition

DOT files convert to SVG for instant visualization of your pipeline topology.

Execution

Multi-Provider Execution

CSS-like model stylesheets assign different LLM models to different nodes. Fan-out to parallel branches. Fan-in with heuristic selection.

Model Stylesheet

/* Default model for all nodes */
* {
    llm_model: claude-sonnet-4-5;
}

/* Critical nodes get Opus */
.critical {
    llm_model: claude-opus-4-6;
}

/* Specific node override */
#final_review {
    llm_model: gpt-5.2;
    llm_provider: openai;
}

Provider Profiles

Claude Code

Extended thinking, agentic tool use, file operations

Codex (OpenAI)

codex-rs style execution in sandboxed environments

Gemini CLI

Gemini-cli style with streaming and function calling

Process

The Build: Multi-Model
Peer Review

27+ Swarm Review
Rounds

Claude Opus & Sonnet

GPT O3 & 5.2 Codex

Gemini

● Design

Each provider's model reviewed the profile designed for its own provider. Claude reviewed Claude's profile. GPT reviewed GPT's.

● Implementation

Code reviewed by 2–3 models per feature, with cross-reviews. Models caught different classes of bugs.

● Validation

Every feature tested with mock tests AND live API calls against all 3 providers.

Security Hardening (Discovered During Review)

path confinement symlink traversal defense shell command deny-list env variable filtering non-blocking shell exec

Results

What Got Built

~90%

Spec Coverage

303

Unit Tests

8

E2E Tests

9

Live Provider Tests

Three-Layer Architecture

Layer 1

types errors retry catalog streaming adapters

Layer 2

session events abort truncation subagent tools

Layer 3

parser engine handlers conditions validation stylesheet

Working features: file I/O, pipeline chaining, parallel execution, subagent spawning, structured output, checkpoint/resume

Takeaway

What This Means

NL specs as a new paradigm — specifications ARE the input, not just documentation
The Software Factory vision is real — specs + AI = working software
Multi-provider swarm isn't just for building — it's for reviewing and hardening
Amplifier's orchestration made the multi-model workflow natural

Specs dropped

→

Sam picks up

→

Amplifier builds

→

Working software

Sam's Implementation

github.com/samueljklee/attractor

StrongDM Software Factory

factory.strongdm.ai

StrongDM's Original Specs