Skip to content
NewBring your Claude Code or Codex subscription

Design. Build. Ship.

One canvas. Designers, engineers, and agents shipping the same artifact. Every idea you draw becomes real, running code. Try ten, keep the one. The prototype is the product.

Mockups are dead.

A new category of product canvas. The prototype is the product.

  • The canvas is the product.

    Move a shape, the code updates. Edit the code, the shape updates. The design and the code are the same artifact — you only have to think about it once.

    Tour the canvas
  • Bring your agent.

    Claude Code, Codex, Cursor, or Copilot — they read your files, write real React, and open PRs to your repo, live on the canvas.

    Meet your agents
  • One room. People and agents.

    Cursors for the humans, ghosts for the agents, one set of files underneath. The same prototype, all the way to shipped.

    See multiplayer
01

One view, everything in flight. Files, apps, and agents in the same surface.

Agents
chat-builder
main
tests
ui-builder
Apps
chat-loop
components
MessageList.tsx
App.tsx
sign-up-loop
components
EmailField.tsx
PasswordField.tsx
SubmitButton.tsx
App.tsx
Mounts
github
prototyper-co
google-drive
Design Files
/apps/sign-up-looplive preview

Sign up to Loop

Create your account in seconds.

02
Sara
main
tests

Direct three agents at once.

Spin one up for the UI, one for the tests, one for the copy. Watch them work in parallel, on the same canvas. Skip the status meetings; the work is the status.

03
Button
App.tsx
<Button variant="primary">
Create account
</Button>

Edit either side.

Move a shape, the code updates. Edit the code, the shape updates. The design and the code are the same artifact — you only have to think about it once.

04
github · prototyper-cosynced
drive · Design Filessynced
mcp · canvas-toolsready

Open with your stack already loaded.

GitHub, Drive, Linear, Notion, Figma, MCP servers, your CI — even your homegrown tooling. All readable from the canvas, the way they live on your computer. Open the workspace and your stack is already there.

Bring the agent you already trust

Open Claude Code. Paste one line. Your agent now works on the canvas.

Open Claude Code, Codex, Cursor, or GitHub Copilot. Paste the install line below. The same agent you already use reads your files, writes to your apps, and opens real PRs — straight from your terminal, live on the Prototyper canvas.

~/my-project — claudemcp connected
$ claude
> Open my Prototyper workspace
[prototyper-mcp] connected · 3 agents · 2 apps · 11 files
>What's main agent up to?
agent · main · idle
agent · ui-builder · 3 writes (sign-up-loop)
agent · chat-builder · 2 writes (chat-loop)
> Add an Email field to sign-up-loop
wrote /apps/sign-up-loop/components/EmailField.tsx
>
What's in the box

One subscription, the work of five tools.

Ship real code

Not a mockup someone rebuilds

Match your brand

Your tokens, on every render

Direct your agents

Steer them like teammates

See it the second it runs

No build step, no waiting

Start with the primitives

50+ typed, accessible, ready

Work from anywhere

CLI, SDK, your editor of choice

Send a link, you’re done

Reviewers see the running thing

Keep your stack

GitHub, Drive, Cursor, MCP

And every other thing you're wondering — yes.

  • Can I bring my own Claude Code or Codex subscription?

  • Can I keep my design tokens and component library?

  • Can my agent read my GitHub repo?

  • Can multiple agents work on the same canvas?

  • Can I sketch on the canvas and have an agent build it?

  • Can I export the code to my own repo any time?

  • Can a designer use this without writing code?

  • Can I run three variants of a design side by side?

  • Can I see what each agent changed?

  • Can I mount Prototyper into Cursor or VS Code?

  • Can I cancel anytime and take my work with me?

  • Can I work on this from inside my terminal?

FromThijs Verreck · founder
SubjectWhy use Prototyper?

Hey there,

There's a good chance we know why you're here.

You're trying to ship something. You have flows to design, components to build, a design system to apply, agents to direct, code to review, deadlines to hit, and a real product to put in front of real users.

You've been doing it across five tools — a design tool, a chat-based generator, your editor, someone else's repo, a project tracker. Five tools means four handoffs. The handoff is where the time goes.

Design used to mean pictures because pictures were all you could deliver. Now an agent can write the code, so the design can be the code. The picture is the smallest part of the work — the skills you give the agent, the plans you write together, and the tools you wire it into are the rest.

Most “AI design” tools missed this. They generate pictures someone still has to implement, and call it progress.

A while back I found myself in the same situation. I wanted to design fast and ship the real thing. I wanted the canvas to be the artifact, not the brief. I wanted the agent, the data, the tools, and the brand to sit next to the canvas, not five tabs away. Nothing fit. So I built Prototyper.

Today, Prototyper is the canvas where designers, engineers, and agents work on the same surface — yours, ours, and the Claude Code or Codex you already pay for. What you think of runs. The prototype is the product.

The canvas is the first room we've shipped, but the substrate underneath it isn't for design alone. It's how we think every team should work — humans and agents on the same surface, the same files, the same accountability. Our mission, plainly, is to make every company agent-native. The canvas is where that starts.

Thanks for checking Prototyper out. Bring your Claude Code or Codex subscription if you have one — we plug right in. Give it a try. We'd be honored to have you as a customer.

Thijs Verreck signatureThijs Verreck · founder
The community

10,000+

real React apps shipped from the canvas — by indie devs, designers, and product teams who got tired of the mockup-to-rebuild loop.

Pricing

Free to start. Pay when you ship.

Free

Free forever

Design, share, ship — with your own agent.

  • 2 workspaces

  • 100 MCP tool calls / week

  • 1 shared collaboration file

  • 7 days of version history

  • Bring your own agent (Claude Code, Codex, etc.)

  • Community support

Pro

Popular

$20.00

/month

For freelancers and indie builders.

  • Unlimited workspaces

  • Unlimited MCP tool calls

  • Realtime collaboration

  • 30 days of version history

  • $25/mo bundled AI credits + metered overage

  • Bring your own agent supported

  • Email support

Team

$80.00

/month
Per team member

For teams that ship together.

  • Everything in Pro

  • $50/seat/mo pooled AI credits + metered overage

  • 90 days of version history

  • Google + Microsoft SSO

  • Roles and permissions

  • Priority support

Start building with Prototyper.

Open the workspace. Drop in an idea. Let an agent take the first shot. Ship the same artifact you sketched.