Design Up, Spec Down

Most design goes one direction: sketch, mock, spec, build. The spec gets written early, and by the time anything ships it's already wrong. I've been working a different loop. You move a design up through fidelity, one medium at a time, sharing at every step, and then you bring the finished thing back down to paper as the real spec.

The path: paper, to a live artifact, to a local build, to production, and then back to paper.

Paper: seed it, then explore

Before the agent draws anything, I give it something to draw from. I collect inspiration, references and work that has the feeling I'm chasing, and I rough out a few of my own ideas by hand. That collection is the seed.

It matters because an agent with no input defaults to the generic average of everything. Seeded with your references and your sketches, it explores in your direction instead. You're pointing it at your taste before you ask it to move.

Then I ideate fast in paper.design, generating and pulling on directions. The goal isn't a finished screen. It's getting the idea out of my head into something I can look at, and starting to shape the static look and feel. Paper is the cheapest place to be wrong, so it's where the exploration belongs.

Then I share the paper link. Feedback here is cheap because nothing is committed yet, and aligning on direction now saves the expensive rework later. You don't want to discover the concept is wrong after you've built it.

The live artifact: give it life

Once the static direction is aligned, I move it into a Claude live artifact and prototype it for real. Interaction, animation, state, the things a static frame can only imply. This is where the design stops being a picture and starts being an experience. You feel it instead of imagining it.

Then I share the artifact and get critique on that. Now people are reacting to the actual experience, not a mockup of it, so the alignment is real. You're settling the questions that only show up in motion.

The build: seed it from the prototype

Because I already have a working interactive artifact, I don't start the build from scratch. I seed it from the prototype, and it's roughly ninety percent there. What's left is production polish: responsiveness, edge cases, real data, the last bit of feel. This stage is refinement, not invention. The risky, generative work already happened in the cheaper mediums; here you're perfecting.

Design backwards: bring it home to paper

Here's the part people skip. Once it's built and real, I bring it back down to paper as a static design: spec artboards that annotate the interaction and the animation. The paper file stops being a stale early sketch and becomes a documented source of truth that matches what actually shipped.

That inversion is the point. The authoritative spec is made last, not first, so it can't rot, because it's derived from the thing that's live. That's what keeps design and build aligned, and it's what lets another designer or a teammate build the next thing against something real instead of guessing at intent.

Why the order holds

Every step raises fidelity, and raising it at the right time is what keeps feedback cheap. You align on direction while it's still paper, on experience while it's still an artifact, and you only spend real build effort once the decisions that matter are settled. Alignment compounds because every stage is shareable. Nothing gets thrown away, because each stage seeds the next. And the loop closes: the thing you shipped becomes the document that describes it.

That's the whole shape. Design up through fidelity, share at every level, let the prototype become the build, then bring it back to paper as the truth. Design up, spec down.