From Figma to deployed site with AI

Can AI help designers become builders?

Can AI Help Designers Become Builders?

Overview

For years, designers have relied on engineering handoffs to bring ideas to life. With the rise of AI coding agents, that boundary is changing.

This project wasn't about seeing whether AI could generate code. It was about exploring a bigger question:

Can product designers use AI to own the journey from idea to shipped product without becoming full-time software engineers?

To answer that, I rebuilt my own portfolio from scratch by directing AI through design specifications, interaction models, structured prompts, and iterative reviews until it matched a premium Figma design and was deployed to production.

The website became both the experiment and the evidence.

The problem

Why this matters

Most AI discussions focus on productivity. I was more interested in capability. Rather than asking, "Can AI make me faster?" I asked, "Can AI expand what I'm capable of building?"

The answer wasn't simply "yes." It fundamentally changed how I think about design.

Instead of ending my process at high-fidelity mockups, I found myself thinking about interaction architecture, implementation constraints, deployment, performance, and motion systems—areas traditionally owned by engineering.

My role

Designer as director, not just author

I owned the Figma design, content architecture, interaction model, and motion timing. Cursor agents handled high-volume implementation; I directed through project rules, Figma node references and it scoped the entire project PRs.

  • Authored Figma design and extracted design tokens
  • Scoped work into 9 feature branches with PR review
  • Decomposed journal interaction into geometry, layers, and state machine
  • Re-exported assets at 2× and 3× when agents delivered blurry mockups
  • Shipped to Vercel after production build verification

Workflow

The shift in workflow

One of the biggest takeaways from this project was that AI changes the designer's role.

Instead of writing every line of code, I spent my time:

  • Breaking complex problems into smaller systems
  • Defining interaction behaviour before implementation
  • Reviewing AI output for fidelity and interaction quality
  • Recognizing when the implementation strategy, not just the code, needed to change
  • Making product and UX trade-offs that balanced design quality, technical complexity, and performance
  • Iterating until the experience felt right

The work shifted from creating artifacts to directing systems.

Design lifecycle

AI across the design workflow

This project also helped me understand where AI creates the most value across the design lifecycle.

StageTraditional WorkflowAI-Assisted Workflow
ExplorationResearch, moodboardsFaster concept generation and exploration
DesignFigmaFigma + implementation-aware thinking
SpecificationStatic handoffStructured prompts, node references, design constraints
DevelopmentEngineering handoffCollaborative implementation with AI
QAManual reviewRapid iteration with AI while maintaining design quality
ShippingEngineering-ownedDesigner-led deployment and refinement

Instead of replacing any stage, AI became a collaborator throughout the process.

Execution

What AI was good at

AI consistently accelerated:

  • Repetitive implementation
  • Component creation
  • Framer Motion implementation
  • Code refactoring
  • Debugging well-defined issues
  • Translating specifications into working interfaces

Once the problem was clearly defined, implementation became remarkably fast.

Decision-making

Where human judgment was essential

The highest-value work remained deeply human.

AI couldn't decide:

  • How the journal should behave
  • What "premium" motion feels like
  • Which interaction model best matched the experience
  • When an architecture should be abandoned
  • What trade-offs were worth making

Those decisions still depended on product thinking and design judgment.

Biggest learning

The biggest shift

The biggest shift wasn't learning React or Framer Motion. It was learning how to communicate with AI.

Good prompts weren't clever. They were clear.

The highest quality outcomes came from treating Figma as a specification system- using node IDs, constraints, geometry, acceptance criteria, and interaction models instead of asking AI to "match the design."

In other words:

Better specifications consistently produced better products.

The challenge

Where AI-assisted builds break down

The hardest problems were not scaffolding- they were fidelity, compositing, and interaction architecture under motion.

  • Hero: 20+ collage items at absolute Figma coordinates with chaos-to-clean scroll staging
  • Work: 3× retina mockups, transparent floaters, hover states that scale only the mockup layer
  • Journal: four architectural pivots before settling on cover-over-spread with idle, parallax, and auto-open
  • AI drift: agents defaulting to flex layouts and wrong fonts without explicit constraints
Journal interaction iterations from scroll flip through 3D passport and layered book to final cover-over-spread approach

AI collaboration

How I directed agents instead of vibe-coding

Prompts evolved from broad asks to measurable specs. Early: “Implement Work section.” Later: “Align with Figma node 1060:14638.” Final: symptom-specific fixes like “Anchor bookmarks spine-relative, single layer behind cover.”

I wrote CLAUDE.md rules — match Figma exactly, no redesign, Framer Motion for animation — and separated content from components so agents had stable targets. Validation scripts for journal assets became acceptance criteria.

Learning

What worked

  • Figma node IDs
  • One issue per commit
  • Animation constants in dedicated files
  • Branch-per-feature PRs kept velocity high without losing control
  • Token optimisation - Instead of relying on long conversational context, I started using reusable artifacts- such as CLAUDE.md, structured content files, component-specific documentation, and stable project rules.

Hiccup

What failed first

Scroll-driven journal flips, single bookmark assets, and 1× image exports all looked close but broke on interaction or retina displays. Each needed a structural fix, not a polish pass.

Decision

Key pivot

I abandoned scroll-hijacking journal animations when they fought page scroll. Tap toggle + 5s auto-open + idle breath replaced a passport-style 3D flip.

Outcome

What this project says about me

This experiment fundamentally changed how I approach product design. AI didn't replace my workflow, it expanded it. By shifting repetitive implementation to AI, I could focus on the decisions that matter most: defining interactions, making trade-offs, and crafting the overall experience.

A single-page portfolio with scroll-driven hero, featured work, interactive journal, Gen AI experiments carousel, writing, testimonials, and footer all statically generated and deployed.

The site is both the artifact and the proof.

Impact

We're moving beyond designing interfaces. We're becoming builders who can ship experiences.

This project isn't meant to demonstrate that I can code. It's meant to demonstrate that I can build. I can take an idea from concept to production by combining product thinking, interaction design, structured AI collaboration, and rapid iteration. To me, that's one of the most important shifts AI is enabling for designers.

Before this project, my workflow ended at Figma. Today, it ends in production.