Show all articles

Vibe coding needs a design contract

AI can turn a short prompt into a new screen. The design decisions behind that screen need to survive the next prompt, too.

By Grum

Keeping designers, engineers, and QA aligned was already a job. A designer chose a pattern. An engineer translated it into code. Then someone had to work out where the implementation might have slipped.

Which page, out of the whole product? Which component or interaction state? The difference might be a few pixels of spacing or a color a shade or two away from the intended value. Even with the right page open, a designer or QA reviewer would have to notice the difference, inspect the implementation, track down the right Figma file or design sheet, and compare the actual values.

That kind of page-by-page, value-by-value review rarely happened. Small differences could ship unnoticed, then get copied into the next screen.

AI development gives those decisions more places to be reinterpreted. As more UI is generated and revised, the amount to compare grows, while finding each small slip still takes the same detective work.

That is the opportunity we see in vibe coding: help people move from an idea to a working product while carrying their existing design decisions along with them.

Alignment was already work

A design system gives a team reusable choices. Making those choices show up consistently in the product takes an implementation and review process as well.

An engineer might copy a nearby component that predates the latest design decision. A mockup might show the default state while leaving the disabled state open to interpretation. A reviewer may not know which screen or state contains the difference, let alone have the right reference beside it.

Existing systems already recognize the need for usage rules. The GOV.UK Design System's style guidance, for example, asks teams to preserve the established meaning of colors and the styling of buttons and inputs.

With AI in the workflow, those agreements need to reach the agent too. A useful design rule sitting outside its working context still depends on a person remembering to bring it into every task.

Three screens, three interpretations

Imagine a team adding a billing page, updating account settings, and shortening onboarding. Each task starts with a reasonable prompt. Each result looks polished enough to keep working on.

But the billing page gets a newly styled payment button. The settings form uses a local input border. Onboarding gets a different heading size because it looked better in the agent's first attempt.

Then another prompt asks for a loading state. Another adjusts the mobile layout. Someone copies the billing page's button into a fourth screen. A local choice starts becoming a pattern before anyone has agreed it should be one.

This is an illustrative scenario, but it shows why drift can be hard to spot. You may need to compare screens, inspect an interaction state, or look at the implementation to notice it. A tidy screenshot of one page doesn't tell the whole story.

Every extra place that makes its own version adds another decision for the team to reconcile later.

A working feature is one part of the review

The payment submits. Settings save. Onboarding reaches the dashboard. Those are useful things to verify, and they don't establish whether the interface follows the team's design decisions.

A test that checks a successful form submission doesn't, by itself, prove that the input uses the approved typography or preserves the intended focus state. Visual review and design checks answer different questions from that functional assertion.

QA needs a clear reference for what is expected. Designers need a way to point to an established decision. Engineers need to know whether a difference is an accident, an accepted exception, or a new requirement worth discussing.

Expecting a final review to uncover every small departure assumes someone can find the affected pages, locate the current design reference, and inspect each relevant value. As implementation speeds up, that manual search has more ground to cover.

Where Grum helps

We use a design contract to make the reviewed tokens, approved components, and usage rules available where the implementation happens. That gives the agent concrete choices to use as it builds.

Before the change: provide the agreement
The agent reads the contract and identifies the approved input, button, and typography choices. The task starts with the team's existing decisions in context.
During implementation: reuse those choices
The agent uses the named tokens and approved components. If a requirement needs something the contract doesn't cover, the team has a specific decision to review.
Before finishing: check for drift
Grum checks the source against the contract. Covered departures can be resolved by returning to an approved choice or following the team's review path.

In our example, that means the billing task can start with the existing button, the settings task can reuse the approved input, and onboarding can reference the shared type tokens. The agent has less to invent for choices the team has already made.

For the departures the source check covers, the team also gets a specific finding to investigate. Review can start with an identified difference in code, rather than depending on someone spotting a slightly different shade while browsing the product.

Instructions and checks work together here. GitHub's documentation on custom instructions explains how repository context can guide Copilot, while also noting that AI may follow instructions inconsistently. Giving an agent a rule is one step; checking the resulting implementation is another.

More room for design judgment

A contract doesn't decide whether onboarding is clear, whether a layout is useful, or whether the product needs a new interaction. Those remain design and product questions.

It can help the team spend less attention rediscovering covered departures from decisions it has already made:

  • Designers can make their approved choices explicit and focus review on the experience and new requirements.
  • Engineers can give agents a reusable implementation reference and resolve concrete findings against it.
  • QA can use the shared agreement alongside functional, visual, and accessibility checks.

There is an important boundary: Grum's source check reports what it can identify in code. It doesn't certify the appearance of a deployed page or the quality of an experience. Testing different screens, states, and devices still matters.

A new design can also be a good decision. The review path lets the team deliberately adopt a new pattern or accept an exception, while keeping that decision distinct from accidental drift.

Keep the momentum and the shared decisions

We want people to try ideas, make useful things, and see their product take shape. AI can be part of that process, whether the person prompting it is a designer, an engineer, or a founder building a first version.

As the product grows, the team needs a way to preserve what it has learned. Which patterns work? Which components are approved? Which changes deserve a fresh conversation?

Grum brings those answers into the implementation workflow. The next prompt can build on the team's decisions, and the next review can focus on what has actually changed.

That is how we want to make vibe coding better: help every new screen belong to the product the team is building together.

Request early access
X Discord LinkedIn