Blog

Figma & Claude Code: shipping this portfolio without a developer

One designer, one AI, no front-end developer on the team. What the workflow actually looked like building this site, where it nearly fell apart, and the design decisions that had to stay entirely mine.

  • Figma
  • Claude Code
  • Art Direction
Katja Shelevytska13 min read341 views

The brief I gave myself

One designer, four weeks, a real deadline, and no front-end developer on the team. Figma for deciding what things should look like, Claude Code for building them, and a rule I kept coming back to: nothing shipped until I had opened it in an actual browser at an actual width and looked at it properly.

This is not a tool review. Tools will look different in six months. What is still true in six months is the shape of the workflow — what I handed over, what nearly went wrong, and the handful of decisions a model will never make for you because it has no opinion to defend.

The Figma frame stayed the source of truth

I designed the hero as a single 1440×800 concept frame in Figma before writing a line of code. Every position and size in the finished section is that frame's own pixel value, converted to a share of the frame's width and rebuilt with a CSS container query, so the whole composition scales as one piece instead of reflowing at arbitrary breakpoints.

The hero went through six versions — only the last two ever existed in Figma.

That mattered more than I expected. An AI is fluent at a loose interpretation of a screenshot — close enough spacing, a plausible type scale. It is not fluent at defending your specific proportions unless you make them literal in the code first. Turning the frame's own grid into scaling tokens removed an entire category of ‘close enough’ results before they had a chance to happen.

The loop that actually worked

Design a section properly in Figma. Describe its behaviour in a sentence. Build it. Open it in the browser. Fix what the browser revealed that the canvas had hidden — which was, reliably, the spacing and the motion, never the layout itself.

A static frame cannot show you a hover state, a scroll-triggered parallax, or what a headline does when the real copy is four characters longer than the placeholder. Those only exist once they are running, so that is where I started reviewing them.

Where taste had to show up, not the model

None of the site's small signature moments came from a prompt on their own. The hand-drawn marker circle around the contact button is a single path with a seeded dash offset, drawn on hover like it was sketched into place rather than faded in. The polaroid on the hero tilts 2.5 degrees, lifts, peels a strip of tape at one corner and writes a note into its own margin — four motion values tied to one hover state, not a generic card-lift effect.

None of that is technically difficult. What is difficult is noticing that the first, generic version — a plain shadow and a scale-up — was wrong for a portfolio built around craft, and being specific enough about why that the next attempt was actually different, not just the same idea re-skinned.

The grain that took a week to get right

The faded, scratched old-photo texture on the dark sections is a canvas painting itself, not an image. The page is split into 1200px document-height tiles, each with its own seeded random generator, so nothing repeats across an 8000px scroll and nothing loads until an IntersectionObserver says a tile is close to the viewport.

Getting the scratches to read as damage instead of decoration took several passes: broken segments with a fading envelope instead of one smooth vector line, uneven line weight, marks that occasionally just stop.

A blend-mode bug is almost always a stacking-context bug. The generated code looked entirely correct — nothing in it was wrong on its own — so nothing would have pointed me at CSS stacking rules except already knowing to suspect them.

Iterating like the client, not the developer

Most rounds were a screenshot and one sentence, not a spec: too much space here, this underline is too thick, this doesn't feel like the rest of the site. The fixes that stuck were the ones where I named the actual pixel, not the vibe — ‘reduce the gap to 64px’ moved things faster than ‘make it feel tighter’ ever did.

The mobile navigation is the clearest example of testing beating assuming. The desktop frame never had to answer what happens at 375px, so the first mobile pass simply shrank the desktop bar — and produced six-pixel text no one could read. It only became a proper top bar with its own expandable menu once I opened it on an actual phone width and could see it was wrong.

Reuse beats regeneration

The contact card that opens from the desktop nav is the exact same component on mobile — once I asked for it by name instead of describing a new mobile version. The hand-drawn marker button drives every call to action on the site instead of five near-identical ones that would slowly have drifted apart from each other.

What I would tell a designer starting this

Bring a finished decision, not a mood. ‘Make it feel premium’ reliably produces the same handful of 2024 defaults — a cream background, an oversized serif, one violet accent. Naming your actual references, your actual type pairing and your actual palette is what keeps the result from looking like everyone else's premium.

Open the real browser before you approve anything. A chat transcript and a static canvas both hide overflow, hover states and real text length. Nothing is finished until you have scrolled it at an actual width.

Ask for the same component again, by name, instead of re-describing something similar. Consistency comes from reuse, not from a fresh description each time that happens to look close.

What stayed mine

The palette, the type pairing, the handwritten motifs, which photograph goes where and why, when a shadow means ‘lifted off the page’ and when it is just decoration — none of that came from a prompt. It came from looking at a screenshot and being specifically annoyed by something, over and over, for about four weeks.

That is the same conclusion I keep landing on with AI in general: the model is fast, and judgement is still entirely mine to exercise. This site is the clearest proof of that I have built so far.

Useful links from this article