How We Designed Shipyard

Give the agent a real environment

Most AI builders keep the model on a short leash. Change this text, swap this color, pick from these templates. It’s safe, and it’s why the output looks the same everywhere.

We went the other way. Every Shipyard project runs in its own isolated sandbox: a full working environment where the agent can install what it needs, run the project, look at the result, and try again. It can read a customer’s existing site, pull down assets, write code, start a preview, and check its own work.

Our bet was that an agent with a capable environment builds better websites than an agent with a menu.

An agent with this much room can make mistakes a template never would. We accepted that trade-off and made the environment itself the safety boundary.

Every project gets its own sandbox

Nothing is shared between customers. A mistake in one project can’t touch another. A customer’s brand assets, offers, and code live only in their environment.

Isolation is also what makes customization possible. Because every project is a full environment rather than a row in a shared configuration, there’s no ceiling on what can be built. A landing page and a maintenance tracker get the same room to work in.

Customers have already used Shipyard to build:

• churn prevention apps
• custom maintenance apps
• weather alert systems
• marketing websites and landing pages
• a long tail we didn’t plan for

There’s no reason someone using Shipyard couldn’t rebuild Nautilus itself, or build the internal tool their operation has always needed and never had the budget for.

The agent knows what a car wash website should be

A powerful agent with no direction builds a generic site, fast.

Before Nautilus, Amayr and I built car wash websites by hand for years. We know what a location page needs, how to explain a membership versus a single wash, where the “Manage My Membership” link goes, how a campaign page should line up with the offer being measured. That knowledge became structured skills the agent carries into every project: specific, opinionated playbooks for how these sites should work, rather than general style guidance.

Then we connected those skills to the rest of Nautilus. The agent knows how to:

• use our APIs for memberships, customers, and locations
• embed our forms so leads land in the CRM
• wire up our e-commerce so a package button opens real checkout
• place everything correctly so attribution and tracking work from day one

A generic builder produces a brochure, while Shipyard produces a surface that is already plugged into the operation.

Where we borrowed

We paid close attention to platforms like Lovable. Two ideas carried over directly: each agent gets its own isolated sandbox, and each project starts from initial components that point the agent in the right direction instead of a blank page.

We made those ideas domain-specific: the starting point is a car wash foundation rather than a general web app, the skills come from our own years of building these sites, and the ecosystem it plugs into is Nautilus.

The system has to survive its own failures

An agent doing real work will hit problems. Sessions run long. Sandboxes get interrupted. A model call fails halfway through a task.

We designed for that from the start. The connection between the agent and its sandbox is durable: work survives a crash and picks up where it left off. Every change the agent makes is committed automatically to a version control system, so nothing is lost and every version can be previewed, compared, and rolled back.

From the customer’s side it looks simple: a conversation that never loses your work. Getting there was one of the harder problems in the whole system.

What we don’t show

We don’t hand the agent a raw sandbox and hope. A lot of setup happens before a customer types their first request. Foundations, guardrails, and quality checks are in place so the first result is good.

There’s more we won’t get into. The skills, the setup, and how the pieces fit together are where most of the work went. They’re why Shipyard’s output looks like it came from a team that has spent years building car wash websites, because the playbooks did.

Why this matters

For customers: Shipyard is a general-purpose builder with deep car wash knowledge and direct access to the Nautilus ecosystem, not a website tool with a chatbot on top. Websites were the first thing it built, and customers are already using it for apps, alerts, and internal tools.

For engineers: the work is agents with real power, environments that make that power safe, systems that stay up under failure, and domain knowledge encoded well enough that a model can use it. If that sounds like your kind of problem, we’re hiring.