Before we write a line of code, three analysts spend the morning trying to kill the idea.
One sizes the market and refuses to accept any number without the arithmetic behind it. One hunts for the moat and rejects “first mover” on principle. One builds the unit economics and won’t sign off on vibes. Then a fourth — the meanest of them — fact-checks the other three, hunting for the claim that isn’t true anymore. They are all the same model, wearing different charters. Most ideas don’t survive the morning.
That’s our incubator. It has no building, no cohort, no demo day. It’s a program.
Last week I wrote about how we build: a lean orchestrator dispatching an org of ephemeral sub-agents — product, architects, engineers, SRE — coordinated through a board. That article left two questions open. Who decides what gets built? And who stands up that org for each new product? The answer to both is the same system, and it rests on one idea: if the org is code, a new company is an instance. Roles are files. Standards are files. Process is files. So starting a new venture stops being a hiring problem and becomes an instantiation — validate the idea, then stamp the org.
The pipeline: an idea has to earn its engineering
The incubator runs a staged pipeline, and every stage is a gate the idea can die at:
- Intake — capture the idea and where it would live.
- Discovery & validation — the research gauntlet (below), ending in a go/no-go.
- Vision & scope — on a go: the executive vision, requirements pillars, phase-1 scope, pricing hypothesis. The founder approves or it stops here.
- Governance — legal, compliance, and accounting agents profile the venture: what data it touches, what rules apply, which standards must be injected.
- Provisioning — the factory stamps out the new startup (the payoff, below).
- Handoff — a fresh session opens in the new repo and starts building with the org from Article 1.
The ordering is the point. Nothing downstream of a gate exists until the gate passes — a declined idea costs a morning of compute and produces a document explaining why, so it never gets re-litigated from scratch. When building is nearly free, the scarce discipline isn’t how to build. It’s whether.
Discovery: research designed to be wrong-resistant
Stage two is where most ideas go to die, and it’s built like a newsroom with a hostile editor.
Three research agents run in parallel, each with a sharp charter. The market analyst owns sizing — top-down and bottom-up TAM, SAM, and SOM, each with its assumptions stated, because a number without a derivation is a guess wearing a suit. It also owns the competitive teardown, with a standing rule I recommend to anyone: the status quo is always a competitor — name it. For most tools, the real rival isn’t the funded startup; it’s the duct-tape workflow people already tolerate. The business strategist owns the model — moat, go-to-market motion, build-versus-buy, pricing hypothesis. The finance agent owns unit economics — CAC, LTV, payback, margin, cost-to-build, runway sensitivity — under an instruction I enjoy more than I should: numbers are deterministic, not vibes — show the arithmetic.
Then comes the stage that changed everything: adversarial verification. A fourth agent takes the competitive claims — who’s funded and by how much, who got acquired, whether the “gap in the market” is actually a shipped feature somewhere — and tries to refute them, demanding a dated citation for every load-bearing assertion. An uncited or stale claim is scored “unverified,” not “true.”
This stage exists because it caught real errors. In one run, the fact-checker flagged that a competitor we’d classified as independent had been acquired months earlier — a stale fact that would have skewed the whole landscape. In another, the honest bottom-up SOM math told us an idea we liked was a solid small-business outcome dressed up in a billion-dollar umbrella TAM — reachable revenue two orders of magnitude below the headline number. The system said, in effect: this is a lifestyle business, decide accordingly. That’s exactly the sentence an enthusiastic founder never says to himself.
The verdict: scored, gated, and recorded
Discovery lands in a decision memo scored against a fixed rubric — six criteria, one to five: strategic fit, value, effort (inverted), dependency readiness, risk (inverted), reversibility. Layered over the scores are hard gates that no score can override: anything touching money or PII requires security-architect review; anything needing new shared infrastructure files a request to the platform first.
The verdict is one of four words: Invest. Backlog. Park. Decline. Park comes with a named trigger for revisiting. Decline comes with the reasons written down — the cheapest insurance there is against the same idea burning a second morning next quarter. And Invest sometimes arrives with training wheels: a probe — a customer-zero build with an explicit graduation trigger — rather than a full commitment. Enthusiasm is not a stage in the pipeline.
The genome: an org you can stamp
Here’s where it becomes a factory.
Everything a new venture needs to operate the way we operate lives in an injectable library we call the genome: the full sub-agent org, the engineering standards, the process docs, the day-0 runbook. The org from Article 1 is in there — PM, information architect, UX, the five architects, the eight engineering roles — but the genome goes further, because a company is more than its engineering. It carries a business org too: market research, strategy, finance, legal counsel, compliance, an accounting controller, marketing, growth, customer success. Twenty-eight roles, each a file with a charter.
Not every startup gets every role. A profile gates the staffing the way a real founder would: a pure product-led company at seed stage gets no dedicated sales agent — founder-led sales-assist instead, because staffing a sales org before there’s a pipeline is how you burn a seed round. Developer relations only exists if the product ships an API. The org chart flexes to the business model, and the gating is code, not judgment calls made at 2 a.m.
On a go, the provisioning engine stamps the selected genome into a fresh private repository, substitutes the venture’s identity into every file, and — my favorite detail — copies the discovery evidence in with it. The market brief, the competitive teardown, the financial model, the go/no-go memo: they land in the new repo’s docs, alongside a provenance file recording the idea, the verdict, and any blocking gates still open. The startup is born knowing why it exists. Six months later, when someone asks “why did we think this market was real?”, the answer is in the repo, not in anyone’s fading memory.
Then a fresh orchestrator session opens in the new repo, reads the day-0 runbook, and the machinery from Article 1 takes over: vision → blueprints → the tank-tread build loop. The pattern is recursive — one orchestrator-and-org decides what to build, then hands off to another orchestrator-and-org that builds it. Same architecture at both layers.
What didn’t work
The honest parts, as ever, are the useful parts.
Early discovery runs produced confident nonsense. A research agent, asked about a competitive landscape, will fluently assert funding rounds, acquisitions, and product gaps with total conviction and mixed accuracy. The parallel analysts weren’t enough; the adversarial fact-check stage wasn’t a nice-to-have, it was the difference between research and creative writing. If you build one piece of this, build that one.
Our own vocabulary drifted. We originally called the provisioned project an “egg” — cute, biological, and wrong for a system meant to speak the industry’s language. We renamed the concept to startup across twenty-nine files — which is to say, our own information-architect discipline from Article 1 had to be turned on the factory itself. Naming debt accrues interest everywhere, including in the machinery that’s supposed to prevent it.
The pull to skip validation is real. When the org is a stamp and the build loop is proven, building feels free — and that’s precisely the trap. Cheap building makes bad ideas cheaper to start, not cheaper to finish. The gates exist because the marginal cost of “let’s just try it” is no longer engineering time; it’s attention, focus, and the slow accumulation of half-alive repos. The pipeline’s job is to keep the portfolio honest.
Why it works: validation compounds like code
Strip it to principles. Cheap, uniform validation — every idea gets the same rigorous morning, the same rubric, the same skeptic, so decisions compare across time. Evidence travels with the artifact — the reasons live in the repo they justify. The org is versioned — improve a role’s charter once and every future venture inherits it; the factory is where thirty years of method stops being tribal knowledge and becomes a default. And decline is a product — a well-documented “no” is an asset most organizations throw away.
None of this is an AI insight. It’s what disciplined investors and studio founders have always done — reduced to files, so it runs the same way every time, at whatever hour the idea shows up.
Takeaways you can use
- Make an idea earn its engineering. Gate the build behind research with teeth, even — especially — when building is cheap.
- Run research as adversaries, not assistants. Separate the analysts from a verifier whose only job is refutation with dated citations. Unverified is not true.
- Demand the arithmetic. TAM without a derivation, SOM without a funnel, LTV without churn math — all vibes. Force the numbers to show their work.
- Name the status quo as a competitor. The spreadsheet-and-willpower workflow you’re replacing is usually the market leader.
- Record every verdict, especially Decline. A documented “no” with reasons is the cheapest way to never argue the same idea twice.
- Gate roles by business model, not habit. No sales org before there’s a pipeline; no DevRel without an API. Encode it.
- Ship the evidence with the artifact. A new project should carry its own justification in its repo from day zero.
Blueprint, not the binary
Same answer as last time: we’re not open-sourcing the incubator — the genome, the charters, and the machinery are part of how we deliver. But the pattern is all here, and it composes from parts you already have. Claude Code gives you the agents and the parallel research; your rubric can be a markdown file; your “provisioning engine” can start as a template repo and a checklist. The blueprint is the article. The factory is yours to build.
As for us — the factory’s first graduates are in their build loops now, tank treads rolling. What we’re learning from running multiple orgs-as-code side by side, and what the board looks like when the portfolio grows, is the next story.
What’s your kill-gate for new ideas — and when did it last actually kill one? I’d genuinely like to hear.
Paul Vilevac is the founder of Bleenq, with 31 years building secure, scalable production systems, now applied to AI/ML platforms and the way software itself gets built. CISSP, CISA, AWS Solutions Architect. This is the second article in Org as Code, a series on how we actually build — the operating model behind the software, not just the software.