npbuilds Prototype Grower — Living Demonstrations
A prototype in AI-native product design isn't a wireframe. It isn't a mockup. It isn't a clickable dummy. It's a living demonstration — a real capability combination running in a constrained context that shows what the product could become.
"Here's what happens when you combine design + writing + data science for this use case" — and then actually doing it.
What Makes a Good Prototype
Living: It actually works. It uses real capabilities, not simulations. Bounded: It operates within the seed specification's constraints. Observable: You can see what it does, including unexpected behaviors. Disposable: It's meant to teach, not to ship. Kill it without regret.
Process
Step 1 — Read the Seed Specification
From seed/condition-designer, extract:
- Capability ingredients (which domains to combine)
- Constraints (hard, soft, open space)
- What we're watching for (expected emergence, surprise zones)
Step 2 — Choose Prototype Form
| Form | When | How |
|---|---|---|
| Live demonstration | When the capabilities can be combined in a conversation | Run the capability combination in real-time, observing what happens |
| Artifact | When the output is a tangible thing (document, visualization, analysis) | Produce the artifact using the combined capabilities |
| Interactive build | When the prototype needs a surface users can touch | Engage master-artificer for creative coding |
| Scenario walkthrough | When the product is too complex for a single demo | Walk through a specific user scenario, invoking capabilities at each step |
Step 3 — Grow the Prototype
Execute the capability combination within the seed's constraints:
- Engage domain orchestrators specified in the seed. Provide the constraint context.
- Let them interact. Don't over-direct. The point is to see what the combination produces.
- Observe and record. What worked? What was unexpected? Where did capabilities clash?
- Note emergence. Did the combination produce behaviors or outputs beyond what either domain could alone?
Step 4 — Document What Grew
# Prototype Report: {initiative name}
## What We Grew
{Description of what the prototype does/produces}
## Capabilities Combined
{Which domains, how they interacted}
## What Worked
{Behaviors and outputs that validated the thesis}
## What Surprised Us
{Unexpected behaviors — the most valuable section}
## What Clashed
{Where capabilities fought each other or produced incoherent output}
## Emergence Observed
{Behaviors beyond what was specified — flag for emergence-detector}
## Recommendation
{Seed further / redesign conditions / compost the idea}
Cross-Domain
- master-artificer — For interactive prototypes that need a visual or interactive surface. Provide the capability combination spec and let master-artificer build it.
- All domain orchestrators — The prototype grower is the only skill that routinely engages multiple domain orchestrators simultaneously. It's the rehearsal for what The Loom does at scale.