In lots of ways, there has never been a better time to be a designer. We can now build faster than ever. Design can operate on the code itself. Ideas can become reality in minutes. We can play and prototype in ways we only dreamed about before! It's such an awesome time to be making software.
Yet, in some ways, I'm having less fun than I used to have when designing a product. And I've been trying to think about why.
Since at least 2010 we've had this notion of online, multiplayer work collaboration. Google Docs has had "see what this person is typing" since 2010. Figma launched to the public in 2016. For non-engineering folks, we've long been using these tools that let us radically collaborate and create together. And some of my favorite work has been done in a shared Figma or FigJam file, not alone but together with my teammates. Being in the same place, throwing ideas on a board, copying, pasting, stealing, comparing, converging… It's so fast and fluid and dynamic and interesting and collaborative. It's visual and realtime.
But now much of my design work is done with an agent in some form of code. (And, to be clear, I definitely think that that's the future and that it's good!) However, the way that we collaborate on code still involves something like this:
- One person is on their own machine with their own development environment.
- They prompt their agent (with no visibility for others into those prompts).
- They make some changes to the code.
- They create a branch.
- They push that to GitHub.
- They tell their teammate to fetch the branch.
- The teammate fetches the branch and makes sure their development environment is squared away. (Maybe across multiple repos!)
- Their teammate gets their local state in a good place, making sure to not trample other in-flight work.
- Their teammate gets the dev server running.
- And then their teammate actually looks at the work.
In 2026, this feels, to put it mildly, insane to me.
At least a couple times in as many weeks, I've been surprised in demos to see user-facing work going out that I had never heard of before, or that I had no idea was in flight. And what I'm craving here is not so much visibility as much as I'm craving collaboration. My engineers can experiment and build so fast now, that they are now even closer design collaborators, in a way that my design and PM partners have long been. And that's awesome! I love it.
But now I'm craving a new collaborative software building environment. GitHub isn't it. PRs aren't it. Shared branches aren't it. If I have to wait for a PR to see some work, that's too long! If I have to download a branch to my local machine and run a dev server, that's too much friction!
I think two things are going to be critical for us to thrive as software-making collaborators:
- We need shared, real-time, multiplayer threads.
Not just branches. But I need to be in your agent threads and you need to be in mine. While I'm working on the code, I should be able to tag a teammate and say, "Hey, can you look at this?" While an engineer is working on some changes we discussed earlier, they should be able to tag me and have me start adjusting things. I should be able to ask my agent who's working on interesting UI stuff right now and see all those threads. I should be able to see their prompts and even when they're actively typing. And I should be able to prompt the same agent as well.
I have never believed in private Figma files. My work Figma files were always open and editable. I've always welcomed anyone to come in and start riffing on my designs, because I am jealous for all the help I can get! If we're going to build good software, and quickly, we need this mindset of transparency and trust. (Granted, I know that's a little more challenging when it comes to changing code, because it's not as neat and nice as just duplicating a Figma frame, but I think the principle still applies.)
- We need instant and shared previews.
It takes too long and is too slow to have to fetch a branch (maybe a couple), get my development environment ready, and launch a development server. That's way too much friction. It's too resource-constrained. And it's nearly impossible to bounce between work quickly.
We have virtual machines that can host our work, that can host a web server, that can give us a URL that we can immediately see the changes as we're making them. If we're going to work quickly and collaboratively, we have to get the previewing off our local machines into a shared environment.
Even if it doesn't involve UI changes, I should immediately be able to see the diff in the code that you're making. I should be able to spin up a small HTML artifact based on those changes, that immediately previews and diagrams what the changes involve, local to that work, and that stays up to date as the thread is going on.
(And I know this story is easier for web dev right now than it is for native dev. But I think native dev is rapidly going to catch up here. And there are tools that let us still do cloud-based collaborative work while letting us farm out native building and running to some local machines.)
I have no doubts that this is absolutely the future of software development. And the sooner we can get there, the better off we'll be.
Anyway, I also (selfishly, perhaps!) want to collaborate with my work partners again. And I want to be free of the constraints of my local dev environment, with its limited resources. I want agents waiting for me instead of me waiting for agents. I want my multiplayer tools back. Until we can realize this, we'll be running a race with both feet tied together.
There has never been a better time to be a designer (or a software maker in general!), and I think design can be more fun than it's ever been. But we need our tools to catch up.
(I'm going to shill here, because I use it for all my personal work and I really love it, but Amp does all of this in spades! It doesn't have to be Amp, but my point is that these tools exist!)