You Make the Path, Part 1: The Setting

Note: This post shares my own experience on a recent project and the patterns I noticed along the way. It isn't a playbook. Every team's setup with AI is different, so take what's useful and leave the rest. Also all views expressed here are my own.

When I think about how I've developed as a designer over the years, there's been a sense of transition that now seems ever more expedited by the advent of AI. You are no longer just one link in the chain; you are embedded in every part of it. A hybrid of product owner, designer, developer and, at times, more. As the landscape has shifted and more tooling has come into play, it makes you wonder how and what "design" really is. Getting to build and work on the new Netlify made me realize that there is no longer one fixed path. You make the path.

Have you ever handed off a design and watched it slowly change shape on its way to production? A spacing value here, a missing empty state there, a label someone "cleaned up." By the time it ships, it's close to what you designed, but not quite.

For most of my career that gap has felt unavoidable. Designers design, developers build, and the handoff in between is where intent leaks out.

On my most recent project, that gap got a lot smaller. Not because of one magic tool, but because I split the work between two very different kinds of AI collaborators and kept myself firmly in the middle.

Setting the Scene

A little over a month ago, I joined Netlify. From my first day I was tasked with a rebrand and reinvention of the product: everything people see after they sign up, from the first screen through to managing a live app. With the backing of two other designers, an exceptional product team and some very savvy developers, we got there in record time.

The primary challenge with this redesign and reinvention was that the product has two very different audiences. Developers have relied on it for years and know exactly where everything lives. But a growing number of new users are domain experts. They've built something with an AI tool, they want it online, and words like "deploy," "build" and "branch" don't mean much to them.

Beyond the user challenge, there was a second one: a new way of building. With a strong push to dogfood our own product, the entire design process had to incorporate Netlify's Agent Runners and other agents like Claude directly into the workflow, not just for efficiency but to lay the foundation for how we'd work going forward.

With both in mind, we started by working out where to focus. It would have been easy to design a "lite" version and call it a day. Instead, the team aligned on something harder: one experience for everyone, where technical detail is layered in quietly for those who want it. Two ground rules kept us honest. Nothing the current product offers could be dropped, and no new features could sneak in. This was about clarity, not scope. We also pushed to make sure exploration could happen quickly and still be driven by data and insights.

I'll also say this up front: I'm a fairly technical designer, and I used to code, mostly front end. When I looked at how to incorporate agents into my workflow, I was looking for a way to spend less time on the mechanics and more time on the decisions. My role as the "human in the loop" was exactly that: understanding the data, driving decisions and acting on changes to push things forward.

Two Collaborators, Two Jobs

When I thought about how I'd work with agents, I pictured a small studio. One collaborator sits next to you at the whiteboard. The other sits next to the developers.

Claude, my design partner: This is where the thinking happened. I worked with Claude inside a project space that held our briefs, research, decision logs and handoff notes, so I didn't have to re-explain the project every time I started a new conversation.

Together we ran competitor research, gathered Amplitude data on the current user experience, built and walked through synthetic personas, explored directions on a design canvas, and turned usability sessions into consistent reports. We also built a suite of Claude skills so that handoffs and records stayed consistent. It was less a tool I prompted and more a colleague I worked alongside.

Netlify Agent Runners, my build partner: Once a direction was settled, Agent Runners turned the screens into a working, hosted prototype. It handled the build, then the endless small tweaks that follow any review: this label, that state, that spacing. When a change was ready, I opened the pull request myself, and our developers reviewed, gave feedback and approved it before it was merged.

That last part changed the most for me. My work didn't end solely as a Figma file and a hope. It ended as real code, in a branch, ready for a developer to review.

This isn't to say there was zero human interaction. In fact, quite the opposite. Time went into discussing feedback and blockers, ideating quickly and making decisions even faster. There was a sense of urgency, but also real joy in working together. The "team" in team really set in, and it sustained us.

The Journey, Week by Week

Looking back, it's hard to believe how much fit into a single month.

Week one, finding the north star: We ran robust initial research (competitor reviews, product analytics in Amplitude, and synthetic persona walkthroughs based on an existing persona library) and moved straight into ideation. Claude helped me explore deliberately different directions on the canvas. By the end of the week the team had agreed on a north star for what the new experience should be.

Week two, a working prototype of the whole app: Within another week we had our first fully functional, consolidated prototype of the entire app, built with Agent Runners. Agent Runners also let several key stakeholders build their own vision of what's next, which was really powerful: we could communicate ideas without relying on words alone. The consolidated prototype wasn't just a clickable mockup. It was a real app! It also carried us through a full round of refinement, adjustment and alignment with the wider team, and really helped guide our thinking and planning.

Week three, putting it in front of people: By the third week the app was solid enough to test with real users. We ran five moderated usability sessions with a mix of domain experts and developers, and Claude helped me turn every session into a consistent report and a running list of findings. Gathering and analyzing data that quickly was a first for me, as user research is traditionally a much longer process. Building our own internal research repo (more on that soon) and getting to insights quickly meant we had solid user insight before launch.

Every day after: Then my role shifted. Updates from testing started landing, and on a daily basis I was opening my own pull requests, making design enhancements and having them reviewed by our developers to be merged. I wasn't handing work over anymore. I was shipping it. This closer connection with the development team gave me deeper insight into their workflow than I've had before, and really solidified a sense of camaraderie.

Launch: A little over four weeks after I joined, the new Netlify went live.

It's rare to be able to say you had a truly end-to-end experience as a designer. In this time I got to watch a concept go from a blank canvas to something offered to the world.

One habit held it all together: decision logs. Every exploration ended with a short written record of what we chose, what we ruled out and why. These logs became shared memory across conversations, for the AI and for me. When a teammate asked "why does it work like this?", the answer was already written down. A daily scheduled task in Claude, sending me a summary of data, insights, decisions and links, also helped me keep a grasp on everything in progress.

What Stood Out Most

Speed is the headline everyone expects. What surprised me were the things that speed made room for.

More time to think, not less: You'd assume moving this fast means less reflection. It was the opposite. With the mechanical parts handled, I spent more time thinking through edge cases, states and the reasoning behind each decision than I ever did pushing pixels.

Flexibility to change and explore: When change is cheap, you stop protecting your first idea. Pivoting after a review, trying a wild alternative, or reworking a flow late in the process stopped feeling like a cost. Ideation stayed open longer, and the work was better for it.

Teammates focused on decisions, not discussion: I leaned on my team more, not less, but the conversations changed. Instead of broad debates about what something could be, we looked at working options side by side and decided. Meetings got shorter and sharper, and the decision logs meant nothing got relitigated.

Technical feasibility up front: Because designs became working code early, feasibility questions surfaced at the start instead of at handoff. If something was going to be hard to build, I knew while I was still designing it, and could adjust before anyone was attached to it.

Up Next

That's the setting: a new team, a big brief, and a month that went from blank canvas to launch. In Part 2, I'll get into the process: where working with agents shined, where I had to push back, and how we kept UX and accessibility at the centre.

In the meantime, the new Netlify is live at netlify.com.

Next
Next

Prototyping an AI support engine - Case study - Part 1