Helix Studio

Helix is a Next.js 16 application with 93 API routes, around 30 Prisma models, a Monaco editor, an xterm terminal, and a seven-phase agent pipeline at its core. It supports building from scratch or importing a real repository from GitHub, GitLab, Bitbucket, Azure, or Gitea, and it previews everything it builds in an isolated cloud microVM before you decide to keep it.

The honest pitch: most AI coding tools autocomplete. Helix tries to own a change end to end, the way a small engineering team would, with a planner, a builder, a reviewer, and auditors that each leave a paper trail.

A single AI assistant bolted onto an editor is great at the next line and bad at the whole job. Nobody plans the work, checks it against the rest of the codebase, hardens it, or verifies it actually runs before handing it back. The result is code that looks plausible and behaves mysteriously.

I wanted the opposite: shipping treated as a pipeline of specialized responsibilities, where every step is inspectable and every generated line can explain why it exists.

A build request runs through seven specialists in order: Planner, Repository Analyzer, Architect, Engineer, Reviewer, Security Auditor, and Performance Auditor. The Planner decomposes the request into a numbered plan. The Analyzer reads the file tree and package.json to detect the stack, deterministically and for zero tokens. The Architect writes a one-sentence technical approach. Then the Engineer, the only phase that must succeed, does the actual building with tools that read, search, and write files.

The last three phases are quality control: a Reviewer reads the diff and issues a ship-it or hold verdict, a Security Auditor runs static analysis for secrets, injection patterns, and risky dependencies, and a Performance Auditor measures bundle weight. Every phase except the Engineer degrades gracefully, so a hiccup in planning never blocks a build. Progress streams to the browser as line-delimited JSON over a single stream, which turned out to be simpler and more reliable than websockets.

Next.js 16 with React 19 gives one deployable unit for marketing, the studio, and all 93 API routes. PostgreSQL through Prisma 7 holds everything from users to the intent ledger. Auth.js v5 handles sessions with credentials, GitHub, Google, and a guest mode that creates a real account with a small token allowance, so people can try the product without a signup wall.

The AI layer is deliberately multi-provider: Anthropic, OpenAI, Gemini, AWS Bedrock, and local OpenAI-compatible servers all plug into one interface. Anthropic requests use prompt caching on the system prompt and tool definitions, which makes multi-hop agent turns roughly 90 percent cheaper on input tokens. Model names are white-labeled so users pick by capability, not by vendor logo.

The studio UI posts a build request to the workspace chat route, which streams NDJSON events back: phase updates, token counts, and a change manifest of written and deleted files so the file tree updates live. Upstash Redis carries the progress channel and rate limiting so both survive serverless instances coming and going. Git hosts are called with plain fetch against their REST APIs, no SDK, through one adapter interface per host.

Code the agents write does not touch the real repository. It lands in a virtual overlay, one database row per created, modified, or deleted file, layered over the base repo. Pushing to the actual git host is a separate, explicit button. That one design decision is what makes the whole thing safe to let an AI loose on.

You connect a repo and Helix creates a workspace that mirrors it, reading files on demand with your OAuth token. Ask for a change and the pipeline kicks off: plan, analyze, approach, build. The Engineer works in hops, up to 24 per turn, reading and searching in parallel and writing sequentially, verifying its own work by running builds and tests inside a Vercel Sandbox microVM.

The sandbox boots your app on a public preview URL that the studio embeds in an iframe, and previews self-destruct after 15 minutes because forgotten VMs are just money with a fan attached. When you like what you see, you push, and the deploy integration links the repo to Vercel, Netlify, Cloudflare, or Render so their native CI builds on every push.

Sessions are 30-day JWTs revalidated against the database, password resets invalidate every session through a fingerprint baked into the token, and OAuth tokens live server-side only. A user's own AI key always works, but the platform's keys never spend for free accounts by accident. The token budget is reserved atomically before a turn starts, which closed a race where two concurrent turns could double-spend a quota.

The intent ledger is my favorite part: every generated line links back to the request that asked for it, the plan step it belongs to, and full before-and-after snapshots. That enables intentional undo, where you reverse an idea instead of a commit. It also means the answer to 'why does this line exist' is a database query, not archaeology.

Serverless statelessness was the recurring boss fight. The sandbox itself became the state store: VMs are found again by name, logs are read from a file inside the VM, and status is inferred by probing the app. Dependency installs were the slowest step, so environment snapshots cache installed node_modules keyed by a hash of the lockfile, with a seven-day shelf life.

I also ran an adversarial QA audit against my own product and it found real issues, including a cross-tenant data leak in a legacy route and that quota double-spend race. All of it got fixed and several fixes are annotated in the code. Only some pipeline phases are model calls; the analyzer and both auditors are deterministic heuristics, and I kept it that way on purpose. Determinism is free, fast, and never hallucinates.

Helix is live at helixstudio.org with 64 passing unit tests, 9 passing end-to-end tests, and a homepage demo that autoplays the pipeline. It ships 24 built-in engineering skills, from test-driven development to security hardening, that bias the agents toward opinionated output. There is even an Electron desktop build for local shell access.

Most importantly, the architecture survived contact with reality: the overlay model, the atomic token budget, and the graceful-degradation pipeline all came out of real failures, and each one made the product harder to break.