I’ve been thinking about how design is changing, not in theory, but in how the work actually happens.
There are two instincts right now.
One is to protect design—craft, taste, intention. Push back on generic AI output, especially chat. It all looks the same, and it doesn’t really solve anything.
The other is to move toward it. Use the tools, work faster, let go of some of the process.
I’m in that second group, not because design goes away, but because it moves.
Over the last week I’ve been working inside something we call Range-in-a-Box. It’s a cloud environment where I can open the product, change it in code, and share a link. No setup, no separate prototype. What I make can ship.
Before, I worked in Figma or Lovable. You could get close—logic, flows, states—but it was still a representation. Someone else still had to build it. Now there’s no translation layer. If it’s good enough, it’s done.
I redesigned our sign-in page. Nothing was broken. I wanted to try a different direction—a split layout that still lets users sign in quickly, while introducing Rai in a lightweight way.
In the past that would have been a prototype and a handoff. Now it’s a PR.
The first thing I ran into was product. This page is one of the most used surfaces, even if it’s simple. There were concerns about clarity and whether this is the right place to introduce something new.
Normally I would involve everyone earlier. This time I didn’t. I wanted to see what happens if you just build it.
It created tension—not because the idea was wrong, but because the process wasn’t clear.
So we wrote one.
Small visual changes go straight to PR. No ceremony, just judgment and transparency. Anything that affects behavior, flow, or metrics gets shared, reviewed, and aligned before it ships.
Speed without structure turns into noise.
The second thing I ran into was engineering. What looked like a small change wasn’t. That page existed in more places than I realized. Small changes touched more than I expected. We went back and forth on the PR six or seven times.
Working in code doesn’t make things simpler. It makes how interconnected everything is impossible to ignore. Small changes ripple.
The work isn’t harder because of the tools. It’s harder because you’re touching the real system.
One piece of advice stuck with me: keep PRs small. Under 300 lines, ideally much smaller. Small changes are easier to understand, review, and trust.
If I did this again, I wouldn’t start with a sign-in page. It’s high stakes. I’d start with something more contained, like a 404 page. Still real, but less fragile.
The biggest shift for me isn’t speed. It’s ownership.
When you ship code, it’s yours. If something breaks, you fix it. You know where it lives. You know who to talk to. You’re not describing the product anymore—you’re changing it.
That changes the role of design.
You don’t need to draw everything. Systems are already there. Engineers can build from them. PMs can shape flows.
So you move differently. You go where the gaps are, define problems, adjust things in place. Less time describing, more time deciding.
It’s also messy. If you’re not there, decisions happen without you. If everyone can ship, quality can drift.
So the job changes. Not more process, but better judgment.
I still use Figma. It’s still useful for thinking through details. But it’s not where the work ends anymore.
The work ends where the product is.
The workflow is collapsing into one place—idea, build, review, ship.
We’re early.
But this feels like one of those shifts you don’t go back from.
