Rivet3 min read Auto

Inside Rivet: what it does, who built it, and what it raised

Rivet puts a visual layer over a web app you already have. You click an element on the page, describe the change, and it edits the actual source on your machine — not a throwaway prototype. It aims at the gap between a designer's file and a developer's pull request.

Compiled automatically from public sources — the company's own posts, launch material and reporting, all linked at the bottom. The “what using it looks like” section is a walkthrough built from public documentation, not a first-hand review. If this is your company, claim the page and correct anything wrong.

The problem they picked

A designer notices the padding is wrong. Three weeks later an engineer maybe fixes it, roughly.

Do that a few hundred times and you have design debt. The product drifts away from its own design system because fixing any single detail costs a ticket, a sprint, and somebody else's attention.

Rivet removes the handoff for that kind of change. The designer edits the running product, and the edit lands in the codebase.

What it actually is

A local visual editor that writes to production code. It runs against the app on your machine. Not an import, not a copy. The actual repository.

You select an element on the rendered page, change it or describe the change, and Rivet edits the real source file.

That separates it from most of the AI-builds-your-UI category, which generates a new artifact. A prototype, a component, a fresh project that looks right and nobody can merge into the app they already have. Rivet only touches code that already exists, and what comes out the other side is a diff.

Gorman frames it as turning product designers into design engineers. The point is giving designers a surface where their judgment reaches production without a translator in between.

What using it looks like

Reconstructed from Rivet's public launch material and demos. A walkthrough rather than a first-hand review. Auto-generated, correctable by the team.

The loop is local. Your dev server is running, Rivet is attached to it, and the app in front of you is the app. You click a component and you're editing the thing that renders, not a properties panel floating over a static mock. Change the spacing, the type scale, the layout. The file on disk changes with it.

Because the repository stays the source of truth, everything downstream keeps working. Changes show up in git diff. They go through the same review any developer's change would. Nothing is stuck in a proprietary canvas waiting to be exported and re-implemented and reconciled.

The limits are structural. Visual editing handles the layer where design decisions actually live: spacing, hierarchy, type, colour, arrangement. It gets much harder the moment a change needs new state, a new data dependency, or a component that doesn't exist yet. Those stay an engineer's job. Handoff doesn't disappear here. The high-volume, low-complexity half of it stops needing one.

The news

September 2025, a $500K seed from Y Combinator, part of the F25 batch. One founder, launched publicly that autumn.

If you're reading funding databases, watch out. Several carry a much larger figure under the name "Rivet". That's Rivet Actors, stateful workload infrastructure, also YC-backed, nothing to do with rivet.design. Collisions like this are ordinary, and they make a decent argument for keying on the domain instead of the name.

Funding

$500Ktotal raised
DateRoundAmountInvestors
Sept 2025Seed$500KY Combinator (lead) · source

Who's behind it

Sam Gorman, solo. He studied Product Design and Computer Science at Stanford, which is the exact intersection the product sits on, then was an early engineer at Snorkel AI leading product engineering teams. He's also built a consumer app past 100,000 users.

@gormankind on X, gormansam on LinkedIn.

Founder

  • Sam GormanFounder

    Early engineer at Snorkel AI leading product engineering; built a consumer app to 100,000+ users. Studied Product Design & Computer Science at Stanford.

Why it might not work

Writing correct, idiomatic changes into somebody's existing production codebase is much harder than generating a clean new one. And the failure mode is nasty: a designer ships something that renders fine and quietly breaks a variant nobody thought to check.

Trust gets earned one diff at a time. The companies who most need this also tend to have the most tangled component hierarchies, which is exactly where editing the real file gets hardest.

Sources