There is a particular kind of stuck that happens early in a project, before there is anything to defend. You have a landing page that works but feels generic, and you have two directions you could take it. One is warm. Cream and espresso, a soft daylight feel. The other is dark, near-black with a champagne accent. Both are defensible. Both have a reference site you admire that proves the direction can carry a product. And you cannot decide, because the thing you are comparing only exists in your head.
This week I stopped trying to decide that argument in my head.
The mistake I keep making
The instinct, when you are unsure between two design directions, is to pick the one you lean toward, build it, look at it, and then, if it is wrong, rebuild. That feels efficient. It is not. The cost is not the building; the cost is that you have nothing to compare the result against. A single rendered design is almost always "fine." You look at it, it loads, the colors are coherent, and your brain, which hates throwing away work, quietly ratifies it. You never see the version you didn't build, so you never feel its absence.
The horizontal version of this same mistake is to argue about the directions in the abstract. Warm feels approachable. Dark feels premium. Both sentences are true and neither resolves anything, because the words are not the thing. A hex value behaves differently in a real layout than it does in your imagination, and the only way to know is to put it in the real layout.
Build both, in branches you can switch between
The move that worked was boring and mechanical. I extracted the design language of each reference site into a small spec, the actual tokens, the type ramp, the spacing rhythm, the way it handles contrast, and wrote each one down as a document, not a vibe. Then I cut two worktrees off the same base branch, one per direction, and applied each design language to the same existing landing page.
Git worktrees matter here in a way a single branch does not. With worktrees, both versions exist on disk at the same time, fully built, in separate folders. I am not stashing and popping and re-running the dev server and trying to remember what the last one looked like. I open one, I open the other, I look at them next to each other. Both build green. Both real. The comparison is no longer a memory exercise.
Then I took a full-page screenshot of each and put them in the comparison document beside the spec. That is the artifact that actually decides things. Not the running app, which I will only ever see one of at a time, but the two screenshots on one page where the difference is impossible to un-see.
Why the spec comes first
The temptation is to skip the written design language and go straight to changing colors until it looks right. I have learned not to. Writing the design language down first does two things. It forces you to name what you are actually borrowing from the reference. Is it the palette, or is it the restraint, or is it the way it uses one accent color and nothing else?, and it gives you something to check the result against. When the warm trial came out feeling muddier than its reference, the spec told me why: I had the palette but not the contrast discipline. That is a fixable note. "It feels off" is not.
It also means the trial is reproducible. A worktree is disposable; I will delete the loser. But the design language document survives, and if I revisit the question in a month, I am not starting from a blank screen. I am starting from two written directions and two screenshots, which is a much better place to start than a feeling.
The general shape
The pattern generalizes past design. Any time you are choosing between two directions that both look plausible in the abstract, two API shapes, two data models, two information architectures, the cheapest way to a real decision is usually to build both, just far enough to look at, in a form you can hold side by side. The work you throw away is small. The clarity you buy is large. And the alternative, picking one in your head and committing before you have seen the other, is how you end up six weeks deep in a direction you would have rejected in five minutes if you had simply put it next to the other one.
You are not committing when you build a trial. That is the whole point. You are buying yourself the one thing the abstract argument can never give you: the chance to look.