Home Feed Profile


The Spec Factory

specai: the 2025 pipeline, the mapping, and the 2026 factoryspecai: the 2025 pipeline, the mapping, and the 2026 factory

TL;DR: Last year I built specai, a heavyweight prompt process that turns product ideas into software. It was designed for Opus 4-class models, 200K contexts, and the Roo runtime; 2026 models carry most of that work natively. So I rebuilt it in a day as a standard skill, runnable by any modern harness. The new specai is a spec factory. A product idea goes in; a verified specification suite comes out; any AI can build the product from it. To test it, I fed it the original 27-line note behind one of my existing products and compared the output with the spec suite that product already had. The results matched in coverage and quality.


The process from last year

In September I told the story of building an LLM developer: forty-eight prompt files taking a short product idea through requirements, domain modeling, user stories, architecture, APIs, service specs, and code, as the figure above shows. It was validated to L2: multi-service products with auth that security couldn’t find much wrong with.

It was built to fit the models of mid-2025: eleven phases sized to 200K contexts, handover files between sessions, the quality loop spelled out in every phase, all on Roo, the one runtime then able to spawn fresh-context sub-tasks. The models of 2026 carry most of that natively: five-fold contexts, agent spawning in every serious harness, skills as a standard packaging. And my own work moved fully to spec-first: for the past year I have developed exclusively from specifications, no vibe coding, with specs as the durable asset and code disposable and regenerated.

The rebuild follows from that: cut the pipeline at the specifications. The new specai turns an idea into a spec suite plus its operating manual, start.md, and that pair is its entire product. Building the software is a separate act, by any AI that picks up start.md.

What comes out of the factory

The new specai is a skill in the standard form, public at github.com/kavehmz/specai: one SKILL.md entry point plus the files it loads as needed, six phase instructions, the standards (the document grammar, the style rules, the change rule, the verification core), and the templates. Twenty-two markdown files, runnable by any harness that can read files and spawn agents. The order-of-magnitude shrink from the 2025 version happened mostly because modern models carry natively what the old process had to spell out; the skill keeps only what a model cannot infer: the grammar, the boundaries, and the gates.

A run produces one repository in a fixed shape:

What the factory emitsWhat the factory emits

The suite absorbs what used to be separate pipeline documents: the domain model lives in the architecture’s glossary, user stories in its lifecycle section, requirements as binding clauses in the component specs. start.md makes the repository self-operable: any AI can build, verify, or change the product from the directory alone.

The process that produces it is the lower lane of the opening figure. Six phases instead of eleven, cut by information rather than token limits: requirements, domain, and stories merged into one Definition pass, while component specs are written by isolated authors that see only the shared contracts and their own scope. The proven 2025 mechanisms stayed: consumer-driven contracts, the 0-10 complexity dial, checkpoint questions.

What happens to a change request

The first question any user of the 2025 version will ask: it had one front door for changes. You asked for a modification, a router judged how deep it cut, and the update propagated downward until the code matched. Where did that go?

It moved, and it works the same way. The product repo’s start.md is now the router, and a request takes one of three paths by size:

A change request, after the splitA change request, after the split

A bug where the spec is already right is a code-only fix. A feature edits its owning spec first, the edit cascades to every spec that cites it, and a builder reconciles the code. A change big enough to reshape the product goes back to the factory as a delta engagement: only the affected phases re-run, in update mode, and the repo is re-sealed before any code moves. The order is identical in all three paths, and identical to 2025: decision, then specs, then code.

The reproduction test

To test the factory I picked a product that already existed spec-first: feedler, a small self-hosted feed reader, mine and in daily use. Its full spec suite and code live in that repo, and so does the informal note that started it, written before anything else existed: 27 lines, typos included (“singple docker-compose bring up the whole thing”).

The experiment: extract that note, run it through the factory with one strict rule, nothing in the run may read the existing repo, and have a blind judge compare the outcome against the original. The clone, built this way from scratch, is specai-feedler.

The reproduction testThe reproduction test

The judge reads the note first and forms its own expectations, then reads both trees, scoring coverage and decision quality, never similarity. My part in the run was four messages: start it, answer eight checkpoint questions, one “continue” after a crash, and “seal it.”

The reproduction run, by the numbersThe reproduction run, by the numbers

Verification ran blind, in rounds, until clean; its best catch was a race condition hiding in plain prose, the kind of bug that normally surfaces months later in production. The judge’s verdict: the two suites are equivalent in coverage and decision quality, each ahead in places, and they landed within one percent of each other in size.

A separate session under Codex (GPT-5.6 Sol Ultra) then built the working product from the new specs, Docker-only. The builder itself declined to declare its build verified; the operating manual forbids self-verification. Everything is in the specai-feedler repo: specs, verdicts, run ledger, and the build.

Where this fits

The rebuild brought last year’s concept up to what 2026 models can do, combined with a year of experience running spec-based development on real products. The factory is written in the same grammar it emits, keeps its own decision ledger, and follows its own change rule.

And it is one component, not the whole answer. The full process of developing solutions in the AI era goes beyond specifications: how products are built, operated, verified, and evolved after the specs exist. That approach is already running behind the trading platform, and I will write about it separately.


Previously: Story of Building LLM Developers · Cognitive Programming Language · Write for the AI That Doesn’t Exist Yet · Hiring Agents in 2026

Posted on July 11, 2026

← Next post    ·    Previous post →