A while back, I wrote about the future of product design in an AI-driven world. At the time, what excited me most was being able to take an idea and turn it into something that actually worked. A real interaction. A little animation. A flow you could play with instead of just imagining. One I could bring to life myself without relying on an engineer. More exploration, more fun.
For a designer who always had ideas I couldn’t quite build myself, that felt like a huge unlock. Another barrier had been lowered.
Tools like Cursor, Claude Code, Figma Make, and Codex have continued opening that door. We can explore an idea while we’re designing it, see what happens in real time, change our minds, and try something else. Sometimes the act of building helps you figure out what you wanted in the first place, at least for me. I design in code how I used to design in Figma.
But lately, I’ve been noticing another shift.
The conversation is moving from “look how quickly I made this prototype” to “could this actually become part of the product?”
And once that answer starts becoming yes, the expectations around our work start changing too.
The live-coded prototype was a huge deal
Think about how we used to communicate a really specific interaction.
You had an idea for how a panel should open, how a transition should feel, or what should happen when someone moved through a flow. You’d try to recreate it in Figma, stitch together a prototype, record a reference, or describe it to an engineer and hope you were imagining the same thing.
There was always some translation involved and back-and-forth iterations.
Working in code gave us another way to explore and communicate those ideas. You could feel the timing, resize the browser, interact with the thing, and discover details that a static screen wouldn’t show you or just things Figma wasn’t capable of.
That changed the conversation with engineering, PMs, and even leadership. We had something tangible to discuss together that resembled more of a finished product.
But there was still an understanding that the code might be disposable. The prototype helped us make a decision, and then someone would build the version that belonged in the actual product.
That understanding is starting to loosen.
Building with the same parts as the product
One of the biggest changes is what these tools can access.
An AI tool working from a screenshot or a description has to interpret what your product looks like. Give it access to your actual components, documentation, and repository conventions, and it has a much better starting point. Context engineering.
A button can be the same button your product already uses. A layout can use the spacing tokens your team maintains. You can work with existing patterns instead of spending half your time correcting an AI tool’s interpretation of them.
I’m seeing this in our own work at Salesforce with SLDS 2, and at Trailhead with our own design system. We’re using the code and components that underpin the product to build our prototypes. Designers are starting to create PRs for review that then get merged into production.
So, if we’re already building with those parts, how much of what we make could carry forward?
Stripe offers a useful example. Design manager Owen Williams built Protodash, an internal AI prototyping system that combines Stripe’s Sail design system with a React shell, an MCP integration, and rules for how the agent should use the project. It later evolved into a browser-based studio for creating, remixing, and reviewing prototypes.
What I find unique is the harness created: the components, instructions, and environment that make the output useful to that particular team.
You can see similar approaches from other companies. Atlassian provides design system tooling for AI agents, including a CLI and MCP server, alongside internal skills covering components, accessibility, styling, and motion. Figma’s Code Connect links design components to their implementations and gives agents more precise code context through its MCP server.
To me, this means that the design system is becoming part of the environment we build in, with more of its rules available while the work is happening. Bringing our prototypes closer to actual production-ready code.
And I think having an AI-friendly design system is going to be increasingly important. We spend so much time making our systems understandable to designers and engineers. Now we need to make them understandable to the agents building alongside us, too. That means clear documentation, actual code examples, consistent component APIs, and guidance on when to use each pattern, all in a format the agent can access and use.
Simply telling an agent to “use our design system” leaves a lot open to interpretation. It needs to know where the components live, how they work, and which conventions matter. The better we make that context, the less time we spend correcting or rebuilding the output. To me, preparing our design systems for AI is becoming a foundational part of making this workflow possible.
Here is a great read by Hardik Pandya on how to expose your design system to LLMs.
So, is it production-ready?
Here’s where I think we need to be a little careful with the language and what this actually means.
Using production components gets you closer, but the feature or component still needs to work inside the product.
What happens when the data is missing? When someone doesn’t have permission? When a request fails? Does the interaction work with a keyboard? Does the change fit the architecture the team already has?
Those questions were always there. Now designers working in the repository can encounter them much earlier and design for them in real time.
There are also examples of this going all the way through review. In a Doctolib case study, Jérôme Benoit Reveau describes a workflow that translates an AI-generated design into React using the company’s Oxygen design system and implementation guidance. A builder used it to address a real user complaint, generated a draft pull request, and had it reviewed by a senior engineer before it was merged and shipped.
It’s one workflow that fits a certain company’s needs, so I wouldn’t treat it as proof that every designer can ship every feature this way. But it illustrates the direction and expectation: a design contribution can arrive as a proposed change to the product, ready for engineering to inspect.
And that is a pretty meaningful change in the product development lifecycle. The lines are starting to blur even more between roles.
The part companies have to figure out
This shift is something everyone is still figuring out, and it comes with its own set of challenges.
If a company wants designers contributing code, there’s work to do internally. Giving everyone an AI subscription is only one part of it. Establishing a way to contribute is a much bigger part.
Designers need access to the appropriate repositories and a clear understanding of where they can work. They need a reliable way to run the product, preview a change, and test it in a development or staging environment.
They also need useful data. That might mean access to test accounts or approved access to staging APIs. Access to the live production database isn’t a prerequisite for designing realistic behavior…representative data and clear permissions can give us what we need to explore it.
And we need to understand what a good contribution looks like. What belongs in a pull request? What should we test? Who reviews it? Who owns the change once it ships?
I think this is a design leadership conversation as much as an engineering one.
If the expectation is shifting toward production contributions, teams need time, support, and a shared process for learning how to do that work. Otherwise, the distance between what the tool can generate and what the organization can actually accept becomes everyone’s problem.
Are we all becoming design engineers?
In my earlier article, I talked about the designer-engineer hybrid. That feels much more tangible now.
Design engineering already exists as a discipline. AI is making some of that work accessible to more product designers, especially those of us who have wanted to get closer to implementation but felt blocked by the technical learning curve.
I’m excited about that. I love being able to work on the details of an experience and actually see them come to life.
But generating code also brings responsibility. I need to understand what changed, why it changed, and how to check it. An agent can help explain the code and run checks, but I still need to be able to discuss the contribution with the people reviewing it.
That’s a different kind of literacy to develop alongside our design skills.
It also doesn’t mean every designer needs the same role. Some will go deep into implementation. Others will focus on research, interaction design, systems, or product strategy. Teams still need that range of expertise.
What I hope changes is how easily those people can work together. Josh Clark describes Big Medium’s designers, product managers, and developers working in the same repository, with requirements and prototypes contributed through branches. That’s a useful picture of where this can go. People bring different expertise into a shared working environment.
What happens to design when we can ship it?
I keep coming back to this because the opportunity goes beyond making our existing process faster.
Imagine noticing a frustrating interaction, exploring an improvement with the actual components, testing it, and opening a pull request for engineering review. The design intent and its implementation can stay much closer together.
Small details that might have been lost in translation have a better chance of making it into the product. We can learn from the constraints while we design, and engineers can respond to something concrete.
Of course, it’s also possible to generate more work than a team can reasonably review. So I think we should pay attention to what actually improves: the experience people receive, the quality of the collaboration, and how much rebuilding we avoid.
I still want room for messy exploration. Some ideas need to be explored and thrown away. We shouldn’t have to justify every experiment as a future production change.
But I do think the default assumption is shifting. More of the work we create can have a path into the product, and that changes how we prepare it and how we collaborate around it.
When I first started building with AI, I was excited that I could finally bring more of my ideas to life.
Now I’m thinking about what it takes to bring those ideas into the products people actually use. And I do believe designers will start to own more of the front end: the layouts, interactions, motion, and details that shape how a product feels. That ownership means staying with the work through implementation, review, and iteration, in close collaboration with engineering. For me, that’s a really exciting direction. The tools are making it more possible. Our design systems, teams, and processes have to make it possible too.
And I think we need to acknowledge that things have already changed. What it means to be a product designer in 2026 isn’t the same as what it meant even two years ago. We’re already exploring, building, and collaborating in ways that are changing the boundaries of the role.
So maybe the bigger question is: what did it fundamentally mean to be a product designer in the first place? Was it the screens we made, the tools we used, or our ability to understand people and shape an experience around what they needed?
For me, that last part is still top of mind. But how we act on it is expanding. If we can design the experience, build more of it, and stay involved as it reaches users, what does it mean to be a product designer now? What should we own, what do we need to learn, and how do we want to work with the people around us?
I don’t think we have a settled answer yet. But I do think we should have a hand in shaping it.
Remember that change is hard, but it’s also where growth happens. It’s okay to accept that design looks different while also saving space to grieve what it was.
Are you being asked to contribute to production code? I’d love to hear your experience with how AI is shaping your role.
As always, stay curious.
The article originally appeared on Medium.