‍Over the last six months, I've increasingly used Claude Code for design work. The biggest benefit hasn't been speed. It's been encountering reality earlier.

Describing software in pictures

For most of my career, code was locked away. It lived in a secret room only accessible to engineers who'd spent years on its mysteries. They alone held the key.

We designers had to describe what we wanted built with pictures. Connected by hotspots. Figma spaghetti.

Then we'd take our pictures to the engineers and ask them to build our vision. Often, months after we'd drawn them, reality would strike. The dashboard breaks down with real data. The interaction model doesn't actually work in code. The motion doesn't quite look right.

We'd point at the screen and say, "Look, just move this 10px to the right."

Sometimes it did move.

Encountering reality earlier

Coding agents like Claude Code and Codex have already transformed software engineering at leading companies. At Anthropic, around 90% of Claude Code's own production code is written by Claude Code. The tool is helping to build itself.

Design is next.

Instead of creating pictures of software, designers now have the tools to build experiences directly in code. Agentic design means leaning into tools like Claude Code to build what we want users to experience. Instead of pushing pixels in Figma, we’re guiding coding agents to design experiences.

Brian Lovin from Notion calls this encountering reality earlier:

"I don't think you can design a good chat experience in Figma. You can design what the chat input looks like, but you can't design what it actually will feel like to use that thing."

Jenny Wen, head of design for Claude at Anthropic, recently said designers used to spend 60–70% of their time mocking and prototyping. Now it's 30–40%. The rest has moved to pairing directly with engineers on working software using Claude Code.

Coding agents also let us explore five different directions in fifteen minutes. They can produce parallel versions of an onboarding flow. They let us feel what it's actually like to use an interactive feature — a chat, a generative interface whipped up on the spot, a dashboard rendered with real data instead of mockups.

In other words, encountering reality earlier.

Recently, working on a tennis opponent scouting app, I asked Claude Code to explore five different ways to design the home view of the app. I delibrately asked it to use a sketchy wireframe style. Exploration is almost free, it took me about 5 minutes to explore the directions in Claude Code, before investing more time in one of them. 
‍

Go slow to move fast

Don't get me wrong. Coding agents can be frustrating.

They're often stubborn. Recently, I had to tell Claude Code three times to center-align three action buttons.

Equally often, they are incredibly good at helping me envision how an experience should feel. Sometimes it's slower to polish an experience in Claude Code than in Figma. That friction comes with a benefit though: we're building a working prototype of the experience, not an abstracted picture of it.

Bringing design to agentic design

Coding agents have mostly been the domain of software engineers. Over the last few months, many of my client teams have started introducing Claude Code to their design teams. We’ve worked together to build the new skills for this age of agentic design. 

The key in making this transition is bringing all our design expertise to how we work with agents. Without guidance, agents default to average-looking and average-feeling UIs. We need to guide them with our taste and intuition. In our AI prototyping workshops, we’ve covered specific ways to guide agents for better design. 

One of the keys is uploading visual examples of the direction you want. Recently, on my tennis scouting app project, I wanted the player profile to have a specific header layout. I tried to describe it in a prompt, but it wasn't until I showed Claude Code an example of what I was after that it produced what I was looking for.

If your team has an existing design system, feed it to the agent in an AI-friendly format — a designsystem.md file works well. This design system will be the starting point for consistent and brand-aligned experiences.

Combining pixel and agentic design

I strongly believe agentic design is the future.

It's hard to fathom that fiddling with autolayouts in Figma is the long-term future of designing real working software. Most people designing and building software will work directly with coding agents.

That said, it's still too early to make a complete jump. In my own work, I'm in Figma 50–70% of the time. Coding agents earn their keep in early exploration and prototyping interactive experiences. For visual polish and full manual control, I still default to Figma.

I often use the two side by side — exploring directions in Claude Code with my project context loaded, then doing the final 20% of polish in Figma. Many designers are experimenting with Figma-to-agent MCP connections to move designs back and forth. The bridge shows promise but is still finicky.

Even with its imperfections, anyone designing software products should bring agentic design into their toolkit. To explore directions faster. To encounter reality earlier. To build intuition for working in the future of software.

Agentic design is a vast topic. I'll cover other aspects of it in future newsletters.

‍