design for AI-built apps

Your AI built it.
Let’s make it not look like AI built it.

Q: Will my AI tools keep respecting the new system?

Yes. That’s a core deliverable. You get a design.md (or tokens.md) brief written for AI consumption, plus an extended component library. When you prompt Cursor or v0 to build the next screen, they have a real system to reach for.

You shipped an app with Cursor, Lovable, or v0. It works. It also looks like every other AI-built app. We redesign the frontend directly in your codebase, tokenized CSS, a real component library, and a design system your AI tools will keep respecting. No Figma handoff, no rewrites, no slowdown.

Talk about your codebase

What it is

Design that happens in your repo.

Senior product design, delivered as PRs. Tokenized CSS, a proper component library, refactored screens. Your app stops looking AI-generated, and your AI tools keep building from a real system.

Traditional product design happens in Figma. A designer mocks up screens, you hand them over, engineers translate them, things get lost in translation. That model assumes the team writing the code can’t make design decisions. With AI coding tools, that assumption breaks. Your code is moving faster than any Figma file can keep up with.

We work the other direction. We open your repo, audit the patterns your AI tools have produced, extract real design tokens, build out a proper component library (often on top of shadcn/ui or a custom registry), and rewrite your screens against that system. The deliverable is a set of PRs, plus a design.md brief written for both humans and AI consumption.

You might be a fit if…

You shipped an MVP with Cursor, Lovable, v0, Bolt, or Claude Code, and the design isn’t holding up.
You’re a founder, not a designer, and you don’t want to learn Figma to fix your app.
You’ve seen the term “AI slop” and recognised your own product in it.
You want the AI tools you’re already using to keep producing better output, not be replaced.
You need senior product design execution without slowing down the velocity AI gave you.

The shift

Figma handoff is a relic.

The old way

Design in Figma. Hand over. Hope for the best.

Designer mocks screens in Figma
Engineer translates pixel pushes into CSS
AI tools generate new screens that ignore the system
Figma file goes stale within a sprint
Visual drift compounds. The app looks AI-built within weeks

The new way

Design in code. Token everything. Brief the AI.

Designer works directly in the repo
Decisions ship as tokens, components, and refactored screens
AI tools build new screens from the same primitives
System is the source of truth, not a Figma file
Your app keeps looking crafted as it grows

How it works

Five phases. Two to four weeks.

Audit the codebase

We read your repo. Map the patterns the AI has produced: the spacing, the colour usage, the component duplication, the inconsistencies. Identify what’s salvageable and what needs to be rebuilt.
Define design tokens

Extract real tokens for colour, spacing, type, radius, motion. Land them in a single source file (CSS variables, Tailwind config, or a tokens.json) that the rest of the system references.
Build the component library

Stand up a proper component layer. Buttons, inputs, cards, modals, the whole base set. Usually built on shadcn/ui or a custom registry so it’s additive, not a rewrite.
Redesign screens in-place

Refactor the core screens against the new system. Real design decisions on hierarchy, density, motion and interaction, shipped as code and reviewed as PRs.
Hand over a system AI will respect

You get a design.md (and tokens.md) written for AI consumption. Next time you prompt Cursor or v0 for a new screen, it has a real system to build against, not a generic baseline.

What's included

What you walk away with.

In the codebase

Design tokens file (CSS vars / Tailwind / JSON)
Component library (often shadcn/ui-based)
Refactored core screens (PRs reviewed by your team)
Before / after visual capture for stakeholders
Cleaned-up utility patterns & spacing scale

For your team (and your AI)

design.md: principles, hierarchy, do/don't
tokens.md: tokens with usage examples
Component usage cheatsheet
Prompt patterns to use with Cursor / v0 / Lovable
30-minute walkthrough of the new system

Investment

Scoped to your codebase.

Pricing depends on codebase size, screen count, and how much of the system needs rebuilding versus refactoring.

Audit & tokens

We read your repo, map what the AI has produced, and land real design tokens.

From R 20,000
Design system

Adds a proper component library, and the design.md and tokens.md your AI builds from.

From R 45,000
Full redesign

Adds your core screens, redesigned in place and shipped as PRs your team reviews.

From R 75,000

Timeline: 2–4 weeks; For most engagements.
Delivery: As PRs; Against a branch of your repo. Your team reviews and merges on their schedule.
Your quote: Within 48 hours; Send the repo (or a screenshot) and we’ll come back with a scope and price.

Common questions

FAQ.

Which AI tools does this work with?

Cursor, Lovable, v0, Bolt, Replit Agent, Claude Code: any tool that ships React, Next.js, or Tailwind-based output. The work is stack-aware, not tool-specific.

Do you need access to my repo?

Yes. The entire premise is designing in code. We work directly in your repo via a fork or branch, push PRs for review, and never block your team from shipping.

What if I'm not using Tailwind?

That's fine. Whether your codebase uses Tailwind, CSS Modules, vanilla CSS, or styled-components, the approach is the same: extract design tokens, define a component library, refactor screens. The toolchain adapts.

How long does this take?

Most engagements run 2–4 weeks depending on app complexity and screen count. Phase 1 (audit + tokens + first component pass) is typically delivered in the first week.

Will my AI tools keep respecting the new system?

Yes. That’s a core deliverable. You get a design.md (or tokens.md) brief written for AI consumption, plus an extended component library. When you prompt Cursor or v0 to build the next screen, they have a real system to reach for.

Is this just refactoring?

No. It’s design, executed in code. The taste, hierarchy, spacing, and interaction decisions are made by a senior product designer who happens to write code. The refactor is the delivery mechanism.