The past twelve months have felt like a sea change in product development. Every week, a new generative AI tool has promised to make us faster, smarter, or more creative. My teams have been using these tools for everything from generating test data to synthesising user research. But I think we are missing the real shift: it is not about the individual tools; it is about the system they are enabling.
If we look beyond the initial buzz, the most significant risk to our current development process is not about job replacement; it is about the collapse of the traditional design handoff.
The problem with design system governance
For years, we have poured resources into building and maintaining enterprise design systems. We meticulously document components in Figma, define interaction models, and then hand this package over to engineering. The goal is to achieve parity; ensuring what the user sees in the final product perfectly matches the design file.
The reality, however, is that this handoff is fraught with inefficiency: it is where interpretation happens, and where debt begins. It is a slow, manual synchronisation loop. We pay a huge cost in time and velocity simply because we have to rebuild the definition of the component (once in the design file, once in code).
My observation in late 2023 is that the most advanced generative models are no longer stopping at creating a static image; they are creating the code artefact itself. They are getting dangerously good at translating natural language directly into tested, reusable components.
This capability exposes the fatal weakness in the current design ops model: if a machine can write the front-end code for a component in a minute, why do we need a complex, time-consuming handoff process that takes days?
From document parity to system autonomy
Our focus needs to immediately shift from document parity to system autonomy.
I believe the next wave of tooling will not just be “copilots” helping designers create screens faster. It will be “agents” that sit between the designer and the codebase, executing multi-step instructions autonomously.
Imagine a future, not far off, where a designer outlines a new dashboard widget in plain language: “I need a graph that shows three metrics, using our primary colour palette, and it must scale responsively below 768 pixels.” The product agent, not a human developer, pulls the tokens from our codified design system, generates the JSX or Vue component, and opens a pull request.
The designer’s job moves entirely away from defining the atomic component structure and towards defining the output goal and the user journey. The engineer’s job moves entirely away from building components and towards maintaining the platform and infrastructure that hosts the agent, and reviewing its output.
This transformation requires product leaders to make difficult choices now:
Codification is King: If your design system is still mostly documentation and static assets, it is vulnerable. We need to double-down on design tokens and coded component libraries now, making them the single source of truth that agents can read and write to.
Prompt Engineering for Product: We need to train our teams, both design and engineering, to communicate with these systems effectively. Clear, unambiguous requirements in natural language will become the most valuable currency in the development lifecycle.
Product management in a frictionless flow
When the handoff friction is minimised, the Product Manager’s role changes. Our energy will no longer be consumed by tracking design implementation debt or verifying adherence to the system. Instead, we can dedicate 100% of our focus to product discovery and strategic alignment.
The focus will shift from shipping features to ensuring the features we build are the right features to begin with. The ability to test hypotheses, prototype, and iterate will accelerate to an almost unbelievable speed. The winner in the coming years will be the company that best leverages autonomous agents, not just for speed, but for uncompromising quality and customer obsession.
If we fail to prepare our systems for this autonomous leap, we risk being left with large, brittle design systems that rapidly become obsolete, acting as a manual anchor slowing down our AI-powered competitors. The time to automate the friction out of the handoff is now.
Mate, I’ve been waiting for this post! Design hand-off is the single biggest source of friction and error in the dev cycle. It’s ridiculous. Designers spend weeks making a ‘pixel-perfect’ mock-up, then developers spend weeks trying to translate that into code, getting it wrong, and then fighting about a 2px difference in padding. It’s a waste of everyone’s time! Figma Dev Mode, design tokens—that is the only way forward. We should be designing in the browser. Brilliant stuff!
This is the pain point for my team! We use Sketch, we export specs, the developers say is too slow to check everything, then the design is not correct in final product. The hand-off is the place where quality always dies. We need to be partners, not two separate teams throwing files.
Designers who still use ‘redlines’ are dinosaurs. It’s 2025. Use tokens or go home.
The problem is not the tool, is the process. Design hand-off is symptom of waterfall mindset. If engineer is part of design critique from very beginning, no hand-off is necessary. Design and code should be single artifact. We use tokens and shared language now, but still the culture is wrong. This is the hardest part to change, I think.