Overview
Most product teams can imagine the next screen faster than they can show it. Ideas sit in slide decks, design files drift away from the brand, and the people with the best product instincts, designers, strategists and partners, wait on an engineer to make anything clickable.
Let’s Vibe Prototypes removes that wait. I designed and built the studio the Let’s Vibe team uses to create and review prototypes of its wellness product: a live site that collects every prototype, a brand and accessibility rulebook that AI assistants must follow, a library of approved components and icons, a design reviewer that checks every change before anyone sees it, and a guided start for people who do not write code. The prototypes themselves, such as the partner program page, the public landing and the wellness hub, were created by Let’s Vibe teammates working in this system. My role was the platform, the standards and the tooling that make their work consistent, safe to share and easy to review.
The result is a team where anyone can turn an idea into a working, on-brand, accessible prototype and a shareable link in a single session, where every change is reviewed for design quality before it is handed back, and where every version, every requirement and every decision is kept, so nothing has to be rebuilt or re-argued later. By my estimate (below), that saves more than 90 percent of the effort of a typical prototype iteration.
The design
The studio is a design system first and a tool second. Every decision below is written down as a rule the AI follows, so the craft survives no matter who is prompting.
A calm visual world
Let’s Vibe is a wellness product, so the studio and every prototype share one deliberately quiet world: muted sage and mist surfaces, deep ink text, warm paper and sand for raised and accent surfaces, generous space and very little motion. It should feel like a sanctuary, not a dashboard.
Colour with a job
- Content and structure use ink, sage, sand and paper, plus a small set of category accents.
- Action has one reserved colour. Every link and button wears a deep pine gradient lit from the top-left, with a soft two-layer shadow on the label; in dark mode it becomes a warm gold. That colour never appears on headings, numbers, icons, dividers or backgrounds, so anything wearing it can be clicked.
- One gold spotlight per screen draws the eye to the single most important thing.
- Numbered steps are content, not actions, so they are ringed in deep sage with ink numerals rather than borrowing the action colour.
Type
Display type is Petrona, a calm, low-contrast serif, paired with Hanken Grotesk, a humane grotesk, for reading and interface. Everything is sentence case, body text holds a 65 to 75 character measure, and nothing interactive drops below 11 pixels. Petrona replaced Fraunces after the design reviewer flagged Fraunces as an overused default. I set three alternatives (Petrona, Young Serif and Bricolage Grotesque) in real Let’s Vibe content, the wordmark, a headline, body copy, numerals and a button, in light and dark, and the team chose Petrona because it keeps the brand’s quiet, literary voice with a steadier rhythm in long headings. Copy follows the same restraint: commas, colons and full stops rather than dashes sprinkled through every sentence.
The orb and the lockup
The brand mark is an orb, a breathing radial gradient. It appears once per view, large, as an anchor, never shrunk into a bullet, and its seven-second breath is the only ambient animation on the page. Orb and wordmark form one lockup that nothing may come between, overlap or slide behind, at rest or in motion.
Buttons with two sizes and every state
Buttons come in exactly two sizes, chosen by the role of the action and never to make a row fit. Regular carries every primary and ordinary action. Small is for secondary actions that sit beside content, such as the About link in the top-right corner of each prototype card; it looks lighter but keeps a full 44-pixel touch target through an invisible extension. Within a size, every button everywhere shares one padding and height. Both share the same states: hover brightens, press darkens and sinks by a pixel, a held selection gains a ring and a tick so it reads stronger than rest rather than dimmer, focus shows a clear ring, and disabled fades to half strength. Segmented switches slide a single thumb between options instead of blinking from one to the next.
Motion as choreography
When the header compacts on scroll, the logo, padding and height are driven by one value, so they move as one gesture. Menus open downward as an extension of the header, the space opens first and the items rise gently into it, and the logo and menu button hold perfectly still throughout. Under reduced-motion settings nothing moves, but colour and opacity feedback stays, so the interface never feels dead.
Dark mode, designed
Dark mode is a second design, not an inversion. Every role is remapped: deep ink pages, pine cards, softened light text, the action colour turned to gold, and deeper, lower-contrast shadows instead of glows. Both modes meet the same contrast and spotlight rules.
Imagery and restraint
Modalities such as reiki or breathwork are shown as typographic cards, never stock photos. Practitioner and event photos always sit over a brand gradient with a scrim so text stays legible. The system also refuses the generic patterns of AI-made interfaces: no small uppercase labels above every heading, no coloured stripes down the side of cards, no icon tiles stacked over headings, no gradient text and no symbols standing in for icons.
One site, everywhere
The studio home page, the component library and every rendered document, from a prototype’s user stories to a source file, share the same header, menu and content column, with the current section marked. Reading a decision log feels like part of the same place as the prototype it explains.
What it does for the team
- Turns ideas into clickable prototypes in one session. A teammate describes an idea in plain language; the AI builds it to the brand, checks it and publishes it, and the live link is ready a minute or two later.
- Opens building to everyone. Designers, strategists and partners build directly instead of waiting on engineering, using copy-ready prompts and one-word commands.
- Reviews its own work before anyone sees it. Before handing any visible change back, the AI runs a design audit, then hardens and polishes the work and adapts it to every screen size, on its own initiative. Nobody has to ask for it.
- Keeps every prototype on-brand without policing. Colour, type, buttons, motion, light and dark mode are rules the AI follows every time, and approved components and icons are reused instead of redrawn.
- Makes accessibility the default. WCAG 2.2 AA, keyboard use, mobile layouts and reduced motion are checked on every prototype, so feedback reflects the real experience.
- Makes feedback precise. Every screen, step and dialog has its own link, so a reviewer can point at exactly what they mean, and Back, Forward and Reload behave like a real website.
- Remembers why. Each version records the original request, the team’s decisions, the requirements it must meet and whether it met them, so anyone can pick up the work months later.
- Builds a shared component library as it goes. Each prototype can try new components freely; once a prototype is approved, the team promotes the best of them into the shared library for everyone.
- One source of truth for the whole company. The brand tokens, icons and components live in one place that other Let’s Vibe codebases install, so the product, the marketing site and the prototypes never drift apart.
- Gives every session the same toolkit. Design references, a design reviewer, browser testing, documentation lookup and deployment checks are ready the moment a session opens, for every teammate and every machine.
- Never loses work. Every version is kept and linkable, nothing is overwritten, and changes publish automatically.
The usual way, and what changes
How prototyping usually works
Without a shared prototype studio, a new idea typically travels like this:
- The idea starts in a meeting or a slide deck. It is described in words and rough sketches, and everyone pictures something slightly different.
- A designer draws static screens. Brand colours and type are applied by hand, usually in one theme and one screen size, and the screens cannot be clicked through.
- The idea waits for engineering. A ticket joins the backlog, and the prototype is built when an engineer has room in a sprint.
- An engineer builds a throwaway prototype. Accessibility, phone layouts and dark mode are left “for launch”, and the code is rarely reused.
- Design review happens at the end, by eye. A designer spots spacing, contrast and state problems late, and each fix needs another round with engineering.
- Feedback arrives as screenshots. A shared link opens on the first screen, reviewers describe where they mean in words, and comments are scattered across chat, email and meeting notes.
- The next round overwrites the last. Earlier versions disappear, nobody is sure which one a stakeholder approved, and the reasons behind decisions live in people’s memories.
- The next project starts from scratch. Buttons, dialogs, icons and forms are redrawn, and other product teams copy colours by hand until the brand slowly drifts.
Every round needs a designer, an engineer and a meeting, so each iteration is slow and expensive, and the people closest to the idea are the furthest from building it.
Side by side
| Step | The usual way | With my approach |
|---|---|---|
| From idea to something clickable | Waits for design, then for an engineer’s sprint | One session: the person with the idea describes it and gets a live link |
| Who can build | Engineers, after handoff | Anyone on the team, guided by copy-ready prompts |
| Design review | A late pass by eye, with fixes queued for another sprint | An automatic audit, harden, polish and adapt pass on every visible change before it is handed back |
| Staying on brand | Applied by hand, checked by eye, drifts over time | Brand rules, approved components and one icon library the AI follows every time |
| Accessibility, phones and dark mode | Deferred to launch, fixed late and at cost | Required and checked on every prototype from the first version |
| Feedback | Screenshots and descriptions of “that screen” | A link to the exact screen, step or dialog |
| Versions | Overwritten; approvals hard to trace | Every version kept, linkable and labelled |
| Why it looks this way | Scattered across chats and memories | A decision log and user stories in every version |
| Reuse | Components redrawn each project | A shared library grows each time a prototype is approved, and other codebases install it |
| Tools and setup | Different on every laptop | The same toolkit, ready at the start of every session |
The difference is not just speed. My approach moves building to the people with the ideas, makes quality the default instead of a final step, and turns every prototype into reusable knowledge and components for the whole company, rather than a disposable artefact.
Time saved: an estimate
How much time does the studio actually save? Below is a careful estimate for one typical prototype iteration, a single landing page or flow about the size of the Sample from Prompt, done the usual way and in the studio. The hours for the usual way are my model of a small product team (a designer, an engineer and a product lead) working to the same standard the studio enforces; they are assumptions, not measurements, so adjust them to your own team. The studio figures come from real runs in this project.
One iteration, the usual way
| Step | Who | Effort |
|---|---|---|
| Briefing and alignment | Designer, engineer, product lead | 3 to 6 hours |
| Static screens in one theme and one size | Designer | 8 to 16 hours |
| Dark mode, phone and tablet layouts | Designer | 4 to 8 hours |
| Handoff and a clickable prototype | Engineer | 16 to 32 hours |
| Accessibility audit and fixes to WCAG 2.2 AA | Designer and engineer | 4 to 8 hours |
| Two rounds of design review and fixes | Designer and engineer | 6 to 10 hours |
| Requirements, flow and decisions written up | Product lead | 2 to 4 hours |
| Publishing and sharing a link | Engineer | About 1 hour |
| Total | 44 to 85 person-hours, over two to three weeks once the wait for a sprint is included |
The same iteration in the studio
| Step | Who | Effort |
|---|---|---|
| Describing the idea with a copy-ready prompt and answering up to three questions | Teammate | 15 to 45 minutes |
| Building, checking (accessibility in both themes, every screen width, deep links, motion) and writing the user stories, decision log, flow and changelog | AI assistant | 20 to 60 minutes of machine time; the Sample from Prompt v2 standards version took 21 minutes end to end, including 13 routes scanned in light and dark mode |
| Two rounds of review and changes in plain language | Teammate | 30 to 60 minutes |
| Publishing | Automatic | About two minutes |
| Total | 1 to 3 person-hours, the same day |
What that adds up to
- Per iteration: about 41 to 84 person-hours saved, more than 90 percent of the effort, and two to three weeks of waiting become an afternoon.
- Per year: a team running four iterations a month saves roughly 2,000 to 4,000 person-hours, about the working year of one to two full-time people. At a cautious two iterations a month it is still roughly 1,000 to 2,000 hours.
- Payback: the studio itself took a few focused days to build, so it pays for itself on its first or second prototype.
- Not counted: reuse across projects (12 shared components and 63 icons that no team redraws), decisions that are not re-argued because they are written down, and late accessibility fixes avoided before launch. These make the real saving larger, but they are harder to measure honestly, so they are left out of the figures.
What your team gets
- A home page that runs itself. Every prototype and every version appears automatically, with its changelog, flow map, user stories and decision log one click away, plus pages for every component library and the icon library.
- Cards that explain themselves. Each prototype card shows a one-sentence description, who it is for and who started it, a small About button and, when a prototype has its own domain, the address where it is live.
- Samples kept apart. Examples of what a prompt produces sit in their own group after every prototype, so nobody mistakes them for a teammate’s product work.
- A guided start for non-technical people. Copy-ready prompts and simple commands in “Start here” take someone from a blank page to a published link without touching code.
- A design reviewer in every session. An industry design skill audits, hardens, polishes and adapts every visible change, and the team’s rules are aligned with it so its findings are real issues, not noise.
- Brand and accessibility built in, not bolted on. Colour, type, buttons, light and dark mode and WCAG 2.2 AA accessibility are rules the AI follows every time.
- Links that behave like a real website. Every screen has its own URL, so feedback can point at exactly what someone is looking at.
- A paper trail. Each version records what changed, what the flow is, which user stories it was built to satisfy and why, and the request and decisions that shaped it.
- React when it helps, with no build step. Prototypes can be plain HTML or React, and both open from a local file or the live site.
- A component and icon library that grows with approval. Shared, approved components and icons for everyone, and a sandbox library for each prototype while it iterates.
Problems and solutions
1. Work gets lost between iterations
The problem
Prototypes were loose files. New versions overwrote old ones, links broke, and nobody could say which version a stakeholder had actually reviewed.
The solution
Every prototype lives in a numbered version folder, and shipped versions are never edited in place; a new iteration is a new version. Each carries a changelog, a flow map and a record of what is real versus simulated. The home page finds new work on its own, so there is nothing to register and nothing to go stale.
2. Only engineers could build
The problem
Designers, strategists and partners had ideas but no safe way into a code repository, so their ideas stayed on slides.
The solution
A “Start here” guide with eight copy-ready prompts and a handful of one-word commands for getting the latest work, starting a prototype or a new version, checking standards, publishing and setting up the team’s AI tools. The AI is instructed to use plain language, ask at most three questions, do the whole job, and finish with a live link and an honest summary of what it checked.
3. The brand drifts with every new screen
The problem
When many people build screens, buttons, links and numbers slowly start sharing colours, and buttons change size from one section to the next, so the product stops feeling like one product.
The solution
One reserved colour for everything clickable, defined as design tokens with a consistent look in every state (rest, hover, pressed, selected, focus, disabled). It is never used for headings, numbers or decoration, so people can always tell what is an action. Buttons come in two fixed sizes, regular and small, chosen by the role of the action, so a section can never quietly shrink its buttons to make them fit. Selected buttons read stronger than the default rather than dimmer, after the team spotted that the old pressed look made them seem muted. The rules are checked automatically.
4. Accessibility depends on who built the screen
The problem
Accessibility and mobile behaviour varied from prototype to prototype, which makes feedback unreliable and launch-time fixes expensive.
The solution
WCAG 2.2 AA is a standing requirement with a checklist the AI must report against, and every visible change now goes through an automatic design review (see 14). The studio’s own pages and the latest version of every prototype were brought up to standard without changing the approved designs: readable contrast, proper page structure, labelled fields, 44-pixel touch targets, visible keyboard focus, keyboard access to everything a mouse can do, text that grows with the reader’s settings, respect for reduced-motion settings, and no sideways scrolling on small phones.
5. Shared links land in the wrong place
The problem
Opening a shared link dropped people on the home screen, and the Back button left the prototype entirely, which makes review sessions frustrating.
The solution
Every view has its own address. Moving between screens adds to history, while filters and search refine the current entry so Back stays meaningful. Signed-out visitors are sent to sign in and then returned to the page they asked for, and unknown addresses show a friendly page instead of a blank screen. Ready-to-paste deep links are documented for each major flow, and when something moves, its old links redirect to the new address.
6. Designs that only work in one theme
The problem
Screens looked right in light mode and broke in dark mode, or the reverse.
The solution
Light and dark mode are required for every new prototype, with a documented colour mapping so the dark theme is designed rather than automatically inverted.
7. Interfaces that jump and flicker
The problem
The sticky header changed height with a visible jump that also moved the page, a closed menu left a ghost of itself over the content, and opening a menu nudged the logo.
The solution
Every state change is a smooth CSS transition, with related changes driven from a single value so they cannot fall out of step. Menus open as a seamless extension of the header, away from the logo, which has visual priority and never moves. When one element animates, its neighbours move with it or stay put, so nothing on the page jumps. Each of these is verified by sampling positions frame by frame.
8. Hosting that fails in production
The problem
The site worked locally but crashed on Vercel because some modern packages could not be loaded by the hosting runtime.
The solution
The server is packaged into a single file at build time and dependencies were chosen to bundle cleanly. The project now deploys automatically on every push to the main branch.
9. Code that is unreadable on screen
The problem
Some files, such as the hosting configuration, are saved on a single line, so the built-in code viewer showed one long unreadable row.
The solution
The viewer recognises the file type and re-indents it for display while still serving the untouched original when it is requested directly.
10. Different AI assistants, different behaviour
The problem
AI assistants working in the same project made inconsistent choices about structure, style and quality.
The solution
One binding rulebook that every major assistant is pointed to, repeatable commands for common jobs, and a verification checklist the assistant has to complete and report on honestly.
11. Nobody remembers why a version looks the way it does
The problem
Weeks later, the original request, the questions the AI asked and the answers the team gave were scattered across chats, so reviewers had to guess why choices were made and decisions were re-argued.
The solution
Every version keeps a decision log next to its user stories: the request that started it, quoted word for word, later requests, the team’s decisions with the options considered and who chose, the defaults the AI picked on its own, and an approval status. User stories link each requirement straight to the screen that fulfils it, so reviewers can check a requirement in one click.
12. Good components were rebuilt for every prototype
The problem
Each prototype redrew its own buttons, dialogs and forms, so effort was repeated and quality varied, and the team wanted React without a build step that would break simple local viewing and hosting.
The solution
Prototypes can now use React loaded from a pinned, integrity-checked source with no install or build. A shared library of approved, on-brand components sits alongside a sandbox library for each prototype version, where new components and variations can be tried freely. Only when a prototype is approved does the team choose which components to adopt, and the shared library is versioned so approved work never changes underneath. A component library page, with the same header as the studio home page and a simple browse menu, shows every library and icon live, in light and dark mode, with usage examples.
13. Every session started with a different toolkit
The problem
The tools that make AI assistants genuinely useful, design reference galleries, real-browser testing, up-to-date documentation and deployment checks, had to be set up by hand, so each person and each session worked with something different.
The solution
The toolkit is defined once for the whole team and prepared automatically when a session starts, so it is ready before the first prompt, in the cloud and on each teammate’s own computer, with personal accounts kept personal.
14. Design quality depended on who wrote the prompt
The problem
Even with brand rules, the quality of spacing, states, edge cases and small-screen behaviour depended on how carefully each person prompted and reviewed.
The solution
I added a dedicated design skill, Impeccable, to the team’s toolkit, gave it the brand and product context so it refines the Let’s Vibe look instead of inventing a new one, and made its review part of the AI’s own protocol: before handing back any visible change, the assistant runs an audit, then hardens, polishes and adapts the work, and reports what it found and fixed. The first full pass covered the studio’s own pages and the latest version of every prototype, with fixes limited to standards so reviewed designs stayed intact.
15. Our rules and the design reviewer disagreed
The problem
Some house conventions, such as small uppercase labels above every heading and coloured stripes down the side of cards, were exactly the patterns the design reviewer flags as generic, so every review produced findings the team had to explain away.
The solution
The team aligned its rules with the reviewer instead of fighting it: those labels and stripes were retired, symbols standing in for icons were replaced by the icon library, and reduced-motion settings now keep visible feedback rather than switching every transition off. The display typeface was the one decision kept for people: the reviewer flagged Fraunces as overused, so I set three alternatives in real Let’s Vibe content, and the team chose Petrona, a calm, steady serif that is now the display face across the brand system.
16. Brand assets copied between codebases
The problem
Other Let’s Vibe codebases copied colours, icons and components by hand, so each copy drifted a little further from the brand.
The solution
The brand folder is now the single source of truth for design and code, installed by other codebases as a package. It includes a shared icon library, available to plain HTML and React alike, so every product uses the same tokens, icons and components.
17. Examples looked like a teammate’s work
The problem
A landing page built from one prompt to show what the standards produce sat among the team’s prototypes, where it could be mistaken for real product work by a teammate.
The solution
Samples now live in their own folder, follow exactly the same rules, and appear in a separate Samples group that is always listed after every prototype, with a description that says plainly what they are. The reference sample was rebuilt to the current standards as a new version, and the original stays untouched for comparison.
18. Cards that said nothing
The problem
The home page listed prototypes by folder name only, so a visitor could not tell what a prototype was, who it served or who started it without opening it.
The solution
Every prototype folder now opens with a short information block: title, a one-sentence description, audience, who started it and when, and, when it has its own domain, its live address. The home page builds each card from it, the rendered page uses it for its title and search description, and authorship is recorded only from evidence, never guessed.
19. Documents felt like a different site
The problem
Opening a prototype’s user stories or a source file dropped readers onto a bare page with no way back, and long documents shifted as fonts loaded.
The solution
Every rendered document now carries the studio’s header and menu, marks the section it belongs to and uses the same content column. Fonts load without reflowing long text, so pages hold still, and scrolling code and tables are reachable by keyboard.
Technical Approach
Architecture
An Express 5 server renders Markdown, shows syntax-highlighted source and serves a home page generated from the folders on disk and each prototype’s information block. It runs locally with one command and in production as a Vercel function, bundled into a single file with esbuild.
Design tokens
The Living Sanctuary brand system ships as CSS, SCSS, TypeScript, JSON and a Tailwind preset, including colour, Petrona and Hanken Grotesk type, spacing, motion, the two button sizes, brand gradients and dark-mode tokens, plus an icon library as SVG files, a sprite and a script, so prototypes and other codebases use one source of truth rather than hard-coded values.
Components
A versioned React component library built only from the brand tokens, with routing helpers that follow the URL rules. Each prototype version can layer its own library on top, and the server discovers every library for the component library page and the home page.
Motion
The sticky header and menus are animated with CSS transitions driven by registered custom properties, so size, padding and position always move together, the logo never moves while a menu opens, and nothing next to an animating element jumps. Under reduced motion, nothing moves but colour and opacity feedback remains.
Routing
Prototypes use hash routes so every view is addressable without server configuration, with consistent rules for when history is added or replaced, focus, page titles and scroll restoration.
Quality checks
Work is verified in a real browser with automated tests: computed-style checks (for example, confirming every button of a size has identical padding and that small buttons still have a 44-pixel touch target), frame sampling during animations, layout-shift measurement, cold-loading deep links, and axe-core accessibility scans in light and dark mode, alongside the design skill’s own detector and its audit, harden, polish and adapt passes.
AI tooling
A shared, versioned set of AI tools for design references, design review, browser testing, documentation, component references and deployment checks, prepared automatically at the start of every session.
Improving existing work
Prototypes that teammates had already built and reviewed were brought up to standard with small, targeted changes rather than rewrites, so approved designs stayed intact; larger changes wait for each prototype’s next version.
Workflow
Trunk-based: small, frequent changes go straight to the main branch and deploy automatically. Each new version ships with user stories that record what it must do, the reasoning behind each design choice and whether each story was met, plus a decision log of what the team asked for and chose. Several AI assistants can work on different prototypes in parallel, each limited to its own folder, with one reviewer checking and publishing their work.
Stack
Node, Express 5, marked, highlight.js, sanitize-html, js-beautify, esbuild, pnpm, Vercel, Playwright, axe-core and the Impeccable design skill. Prototypes are plain HTML, CSS and JavaScript, or React 18 with htm.
How it works day to day
A teammate opens the home page, copies a prompt into Claude and describes the idea. Their tools are already set up. The assistant brings the project up to date, creates the prototype with the brand system, approved components and icons, writes the user stories, decision log, flow map and changelog, runs its own design review and the standards checks, and publishes. Within a minute or two the teammate has a link that stakeholders can open on a phone or laptop, in light or dark mode, and share screen by screen. When the team approves a prototype, its best components join the shared library and make the next prototype faster still.
What this demonstrates
This project shows how I combine product thinking, visual and interaction design, design systems, accessibility and engineering to build the platform and standards that let a whole team, not only its engineers, produce consistent, considered prototypes quickly, review them to a professional standard automatically, and keep the knowledge behind them. The same approach can be applied to your product, brand or internal tools.