taste is the stack
brand, design system, site, blog – the full build and what held it all together
I built a personal site from scratch – brand, design system, components, CMS, deploy pipeline, the entire thing. This post is about what that actually looked like, decision by decision.
The interesting part wasn’t any single layer. It was watching taste compound. A color decision made in week one showed up in a component six weeks later. A voice constraint I wrote down once kept a publishing workflow honest months after. Every layer talks to the ones around it – and the ones that came before it.
If you’ve ever tried to build something where every piece needs to feel like it belongs together – not just work together – this is what that process looked like for me. The brand came first.
I build digital products. End to end – design, product, engineering. I also lead a Digital Studio in a consulting org. Both are true at the same time. Any brand that only captured one of those would be wrong.
The discovery process started with personality, not pixels. How I describe myself: direct, simple in word use, not sophisticated for the sake of it. How I want to come across: cool, approachable, someone you want to talk to at a dinner party. Not disruptive. Not performing.
What I care about in a build: user needs, the right flow, fewest steps, clarity of intent. Not features. Not technical novelty. Whether it does what it’s supposed to.
Three taglines came out of this work. The one that stuck: “where craft meets clarity.” It’s the simplest and the most honest.
The palette didn’t come from a color wheel. It came from my wardrobe.
Fourteen garments photographed and analyzed. The finding: every piece I gravitate toward has the same color registers – terracotta, warm parchment, forest teal as a depth field. No cool tones anywhere. Every light base is warm-shifted. This wasn’t designed. It was instinctive. The brand palette just made it explicit.
What surprised me: it wasn’t just the dominant colors. The accents match too – dusty rose, amber, copper – all sitting in the same desaturated earthy register. Even the graphic vocabulary repeats: botanicals, sun motifs, hand-carved textures. Fourteen pieces, bought over years without thinking about it, and they already agree. The brand didn’t invent a palette. It recognized one.
The logo took longer. I tried a Playfair Display KV first – beautiful typeface, wrong fit. Then a rounded shield emblem – explored and moved past. What worked: a geometric stroke mark where the K and V overlap physically. The K is the structured foundation. The V is heavier, more dominant, crossing over the top. The tension between them is intentional.
The front/back principle came from the same wardrobe analysis. Every piece I own has a quiet front – a small mark, sometimes nothing – and an expressive back. That’s the brand architecture in physical form. Surface layer: restrained, confident. Discovery layer: depth, earned on engagement.
The illustration work started with a constraint: find the physical scene that IS the concept. Not one that represents it.
That distinction changed everything. Symbols borrow meaning. A scene earns it.
The vocabulary that emerged: whiteboard, marker, coffee. The whiteboard is where ideas live before they’re built. The marker is the thinking instrument – capped means paused, uncapped means mid-session. The coffee ring is evidence of time spent.
One terracotta moment per image. It marks what matters – the accepted compromise, the connection finally made. Never decorative. Never more than one. In an after state – something shipped, the constraint gone – the terracotta disappears entirely.
Directions that got rejected: a grid of squares meant to signal “building blocks” – too literal, borrowed meaning. Anything photographic. Anything symmetrical. Every expressive piece in my wardrobe is abstracted and organic. The illustration vocabulary had to match.
Taste has to survive delegation.
If a tool can write for me, design for me, publish for me – it has to meet the same bar I hold myself to. Not close enough. Exact. I built specialized skills – agents with locked brand constraints – for that reason. Not to automate. To see if taste could transfer.
The standard for a skill working: it produces something I don’t need to correct.
But getting to that standard takes work. That’s where evals come in.
Every skill I built went through the same loop. Run it. Read the output. Ask one question: does this sound like me, or does it sound like someone describing me?
The difference is obvious once you see it. “Someone describing me” uses words I’d never say. It reaches for sophistication. It frames the independent work as lonely. These aren’t small misses – they’re the wrong person.
So I ran evals. Not automated benchmarks. Deliberate sessions where I gave the skill a prompt, read what came back, and marked every line that was wrong. Not wrong as in incorrect – wrong as in off-brand. Wrong as in I’d never publish that.
The eval viewer made this visible. Outputs side by side, version over version. I could see exactly where the voice broke and what caused it.
Every correction went into a log. Not loosely – specifically. “Don’t use ‘building alone’ – it erases the dual identity.” “Don’t say ‘on-ramp’ – not my language.” “The closing structure goes: old constraint / what I can do now / I’ll take that trade.” Each entry is a verdict, a reason, and a rule.
The log becomes the memory. The memory becomes the constraint. Next session, the skill loads that log and doesn’t make the same mistake. The sessions get cleaner over time – not because the model changed, but because the corrections accumulated.
The standard I held it to: produce something I’d be comfortable publishing without changing a word. That’s a high bar. It took time. But that’s what evals are for.
Once the brand had a language, that language needed to become code.
Storybook is where the design system lives. Every token – color, typography, spacing, radius – traces back to a brand decision made upstream. The palette isn’t hardcoded in components. It’s referenced from a single source. Change the token, change everything.
The components built on top of those tokens: buttons, cards, navigation, the blog post layout you’re reading right now. Each one knows the system it belongs to.
This is what a design system actually means in practice: not a Figma file with color swatches. Code that enforces taste.
Headless WordPress as the CMS. Next.js on the frontend. Supabase for the database layer. Vercel for deployment.
Every choice was about removing friction from the wrong places so I could spend time on the right ones. WordPress because content management should work, not be a project. Headless because I wanted full control over how things look and feel. Next.js for rendering flexibility. Supabase because the database shouldn’t slow down a brand decision. Vercel because deployment should not be a problem I spend time on.
Taste shows up in architecture as the things you refuse to compromise on – and the things you deliberately make someone else’s problem.
The pieces connect cleanly. WordPress exposes content via REST API. Next.js fetches, renders, serves. Storybook documents the components. The design tokens flow from brand decisions down into every layer.
MCP servers are what turn Claude from a chat into a collaborator with real tools.
Each server connected for a specific reason – Figma for the design system, Playwright for visual testing, Supabase for the data layer. Not because they were available. Because taste needs to survive the handoff between tools, and every gap in the chain is a place where standards drop.
Taste without verification is just opinion.
Every layer of this build has a verification step. Design: screenshot review at checkpoints – spacing, contrast, alignment, hierarchy. Does every component look right at every breakpoint. Engineering: Playwright tests for behavior, preview tools for visual confirmation before anything ships. Content: voice pass against the feedback log before anything publishes.
The standard across all three: does it look right. Does it work right. Does it feel right.
All three. Every time. Not two out of three.
You build it, it mostly works, you ship it. But “mostly works” and “looks right” are not the same thing. The gap between them is where taste lives.
The first thing I shipped was this. The brand. The design system. The site. The blog.
Every decision in it – color, type, component, architecture, voice – was filtered through the same question: does this meet the standard I actually have?
The old constraints kept me from asking that question seriously.
Being able to answer it keeps me from stopping.
I’ll take that trade.