The Interview: The Workshop's Front Door
The Premise
“Flip the script. Don’t ask the questions - tell the agent what you want, and work with it to come up with the plan to get you there.”
That is the whole bet. The Interview is the station where context enters.
Every deep dive on this site started as a conversation in this app. Sqzarr started here. Fork the Vote started here. Boopadoop, Sidefire, the Timeline: all of them came through some version of the same intake. The Interview is not a product. It is the first station on the line, and everything downstream is downstream of what it captures.
Why It Exists
The standard way to turn “I have a problem” into working software is a chain of humans. Client talks to PM. PM writes a ticket. Engineer reads the ticket, guesses at the parts the PM didn’t write down, and ships something close enough. Each handoff loses specificity. Each loss compounds.
Mass production solved this for physical goods by standardizing the handoffs, not the outputs. Every Model T chassis came out of the same line. Every one of them was different in the ways that mattered to the owner.
The Interview is that standardization, applied to bespoke software. The line doesn’t produce one kind of thing. It produces whatever the person at the front door described, using the same set of stations every time.
How It Works
The interviewer is adaptive, not scripted. It tracks seven coverage topics internally without showing them to the user: what the thing is, who it’s for, what goes wrong, what done looks like, how we work together, constraints, and a final structured confirmation. It picks the next question based on what the user just volunteered, not a fixed order. Short-answer offramps exist for users who want to move fast.
Alongside the chat there’s a sketch pane. Four canvas modes (free spatial, mind map, flowchart, timeline) let the person draw what they mean when words aren’t enough. Every edit feeds back to the interviewer as a natural-language delta plus the full canvas state. The sketch and the conversation stay in sync.
Under the hood, domain adaptation runs on a trait system. Around a hundred tokens of disambiguation context per trait is enough to shift a cheap model from wrong answer to right answer. Traits compose: an Android app with a compliance workflow stacks the mobile trait with the compliance-ops trait. Unknown traits get generated on the fly at about a tenth of a cent each, cached after the second hit.
When the user confirms scope, the line runs. Nine stations: Interview, Extraction, Solution Design, Specification, Production, Quality Check, Delivery, Review, Feedback. Each one consumes the previous station’s output. The first deliverable off the line is a config manifest: every concrete operational value the project needs, with open items flagged. Architecture reads the manifest. Workflow reads the architecture. Code reads the workflow. Nothing re-interprets the raw transcript. One authoritative chain of decisions, one artifact per station.
A scale level (L1 throwaway through L5 enterprise) rides along the whole run and gates which constraints apply. An L1 script for a one-off doesn’t get architecture-reviewed into oblivion. An L4 production build doesn’t ship without the review stations the L1 skipped.
The UI
Six tabs, one project at a time.
- Interview. The chat itself. Voice or text.
- Pipeline. Live station runs after the user confirms scope. Each station shows its own status and its own output.
- Outputs. The generated deliverables. Manifest, architecture, workflow, mockups, code packet, audit.
- Context. Uploads, screenshots, prior sketches, existing-repo analysis.
- Log. Append-only decision log and event stream. Every judgment call the line made is in here.
- Quality Audit. Cross-artifact consistency checks. Does the workflow actually implement the architecture. Does the code actually implement the workflow.
A Costs tab tracks model spend per project. A scale-level badge (L1 to L5) sits in the top right of every project view.
The Numbers
- Coverage topics per interview: 7
- Assembly stations: 9
- Time per interview: about 15 minutes
- Cost per full run: under $0.30
- Tier-1 domain traits shipped: 10
- Scale levels: 5 (L1 throwaway to L5 enterprise)
- Sketch canvas modes: 4
- Cost to generate a new trait on the fly: about $0.001
What We Learned
v1 of the pipeline ran the post-interview artifacts in parallel. Architecture, workflow, and code packet were all generated from the same raw transcript at roughly the same time. It seemed efficient. The output was three documents that disagreed with each other in small, infuriating ways. A field named in the architecture would have the wrong type in the workflow and be missing from the code packet. Every parallel re-interpretation introduced its own drift.
v2 linearized the chain. The config manifest runs first and is the single source of operational truth. Everything after it consumes the manifest, not the transcript. Architecture fills in implementation. Workflow organizes architecture into phases. Code implements the workflow. The transcript is preserved, but nothing downstream of the manifest is allowed to rewrite it.
That one change is the difference between Fork the Vote’s first build (eight deficiencies, two critical, an abandoned draft) and its second build (shipped, used, done).
The Throughline
The Interview is the meta-tool. Sqzarr is a transcoder, the Interview is what made Sqzarr. Fork the Vote is a voting app, the Interview is what made Fork the Vote. Every fix to the Interview makes every future product better for free.
That is the entire bet. The line matters more than any single thing it produces. Improving the line once compounds across every run after it. Improving any individual product only helps that product.
Most software companies ship products. This one ships a line that ships products.
Current Status
Live at interview.throughlinetech.net. Repo is private; the live URL is the way in.
In heavy dev. Recent work:
- Sketch modes. Spatial layout, mind map, flowchart, and timeline canvases, with grouping, persistence, and multi-select.
- Pipeline progress feedback. After scope confirmation the user now sees live station runs stream into the Pipeline tab instead of staring at a blank screen.
- Open-item persistence. Resolved and dismissed open items now survive a page refresh.
- Generate-endpoint error UX. Proper loading states and throttled polling instead of silent failures.