Code First, Design Second
We built software the way we did because code was expensive. It's not anymore. It's time to put the cart before the horse.
The bottleneck moved
The hard part of building software has never been the frontend. It's always been the stuff no one sees — the schema design, the data model, the backend, the APIs, the infra. That's where the real decisions live. That's where you make the mistakes that cost you six months to untangle.
The frontend? That was hard because it was tedious. Now it's not.
Ask v0 for a reasonable UI for your idea and you'll get something shippable in 30 seconds. Take it into Claude or Cursor and iterate. Ship it. The part of the stack that used to take weeks of designer-engineer ping-pong now takes an afternoon.
So why are we still designing first?
The new order of operations
Here's what the process should look like now:
proto-design → code → merge → polish.
Engineers can prototype a real, working UI before a designer ever opens Figma. Yes, it might be rough. Yes, some engineers have the design sensibility of a CRUD form from 2009. That's fine - because the designer-forward people on the team can iterate and polish after the thing exists. Frontend code is cheap to churn now. Redesigning a working feature is way less painful than rebuilding a feature that was designed wrong.
You're not skipping design. You're just moving it to where it belongs - after you know the thing actually works.
This isn't anti-designer
The designers on your team are still essential. But their highest-leverage work is not translating a product spec into a wireframe before a single line of code is written. It's taking something real and making it excellent. That's a better use of their talent anyway.
The old model asked designers to design in a vacuum and engineers to build to spec. The new model asks engineers to build a working thing fast, and then everyone makes it better together. One of those processes produces software. The other produces Figma files.
Stop waiting for the design to be perfect
Perfect design before code is a trap. You don't know what you're actually building until you've built it. The interaction that looked clean in Figma is awkward in practice. The component that seemed obvious needs a loading state nobody thought about. The happy path is fine but the edge cases are a mess.
Code tells you the truth. Figma lies - beautifully, but still.
Build the thing. Ship the thing. Then make it pretty.
