Sandcastle

Every design project starts with the same tax: someone has to make the first version before anyone can react to it. For a product designer that's a mockup, a careful picture of software that doesn't exist yet. It takes hours, goes stale when the real components change, and still has to be translated into code.

At Pulumi I stopped paying that tax by hand. In March 2026 I built a design sandbox in Storybook on the Pulumi Design System's Web Components that emulates production. In October I added Sandcastle, an agent harness that fields Linear tickets and Slack requests and generates first-revision prototypes in it. I vet every one with my own judgment, and I create new experiences in the sandbox every day. I wrote about the way of working behind it in Drafts While I Sleep.

The problem

Design requests arrive faster than first versions can be drawn, and a picture of a screen is a weak handoff. The goal was a first draft that is already made of the product, so review starts from something real and engineers can open, inspect, and reuse it.

How it works

A scheduler wakes the system a few times a day. For each new request, an agent makes a judgment call before anything gets built: does this already exist, is it clear enough to build, and can it be shown as a prototype at all? If it's unclear, it asks one specific question instead of guessing.

When a request is ready, a headless coding agent works in its own isolated workspace. It reads the repository's design rules, finds the closest existing patterns, and builds interactive states from production components. It checks its work the way an engineer would, with type checks, linting, and validation, then opens a pull request labeled as an agent-generated draft and links it back to the request.

None of the parts are exotic, and there are no servers to maintain:

• Agent: Claude Code in headless mode (claude -p), with Sonnet 4.6 for triage and builds, under a cost cap on every run.
• Scheduler: macOS launchd runs it at 8:00, 12:00 and 19:00, and an always-on listener answers Slack.
• Chat: a Slack app called Sandcastle.
• Glue: Linear's API reads tickets and attaches the pull request, the GitHub CLI pushes branches and opens drafts, and GitHub Actions posts a Storybook preview on each one.

Designing for when the output is wrong

Getting an agent to write code was the easy part. The design work was deciding where it stops, and what happens when its draft is wrong, which a fast first pass often is.

• Drafts, not decisions. Everything is a proposal. Marking a draft ready, or merging it, is a separate step only a person takes.
• Attributable. It runs as me, with my own accounts, so every pull request traces to a person who is accountable for it.
• Backpressure. When too many agent drafts are waiting for review, scheduled work pauses. Direct requests still go through.
• No ambiguous silence. Every scheduled run reports, even when nothing was ready, so a quiet morning never looks like a broken system.
• An off switch. One message pauses scheduled work while I'm away.

Memory is the multiplier

Every agent session reads a set of written instructions and per-project notes first: the requester's words, quoted and dated, the decisions so far, and the open questions. After a build, the system starts notes for the new prototype: what was asked, what the agent assumed, and what it couldn't decide. Those notes did more for quality than any model upgrade has.

One request, start to finish

On October 19 I mentioned Sandcastle in Slack with four ticket links. It took the first three and said so. Eight minutes later the first draft pull request was attached to its ticket, and the thread had the link, the Storybook path, and the open questions the agent couldn't settle on its own.

The ticket asked to rename two sections of an unreleased settings panel, with a caveat about a naming collision. The draft did exactly that, and it was thin. I replied in the same thread asking for the full create and edit flows, and the agent added a commit to the same draft for $3.85. My review found the problems you'd expect from a fast first pass: the rules were too flat, some states were wrong, and the agent's own reasoning had leaked into the UI copy. Fixing them was still faster than starting from a blank page. The next day the reviewed prototype was merged, with the naming decision settled.

Outcome

In its first week, October 16 to 23, 2026, counted from Sandcastle's run logs and GitHub:

• 19 Linear tickets turned into agent draft pull requests. 5 have been reviewed and merged so far, and 1 was closed as a duplicate.
• 21 agent builds, all successful. The median build took 7.9 minutes (5.3 to 17.6) and cost $2.60. Runs with nothing new to build cost nothing.
• From a Slack request to a reply with a draft: 7m49s and 17m17s for single tickets, and 24 minutes for three tickets in one request.

An idea that would have waited a week for a mockup gets an interactive draft the same afternoon. Handoffs are made of production components, so engineers reuse the structure directly. And my job shifted from producer to editor: more options reviewed, a higher quality bar.

Related: Vibr

Vibr brings the same loop to anyone with an API key. Describe an interface in chat, pick a design system from npm, and an agent plans, builds, checks that the result renders, and repairs it once before handing you a draft. It works with Gemini, Claude, and OpenAI models and runs entirely in your browser: no backend, bring your own key. The screen draws itself on the canvas while the model writes it, and each idea can be saved with its versions to a library or exported as a working web app for a demo.