The end of the Uncanny Valley between design and code

Collaboration meant constant translation between stakeholders.

Product managers pushed business requirements and aligned work with organisational goals. Designers created experiences in tools like Figma, focusing on interaction, structure, and visual clarity. Developers took those designs and rebuilt them in coding environments like VS Code, connecting APIs, writing logic, and making the product actually work.

Between these worlds sat documentation, handoffs, meetings, revisions, and countless small translations that turned design intent into implementation.

The process worked, but it was slow and often inconsistent. Every design decision had to be reinterpreted. Every component had to be built or rebuilt. Every update required coordination. Much of the work was repetitive, manual, and fragile.

Then AI arrived, bringing more potential, more tools, and — if we’re honest — more chaos and inconsistency between these stakeholders. Suddenly every role was declared “dead” because it seemed like product managers could design and designers could code overnight.

The noise got louder. AI was doing amazing things in isolation, but there was little evidence that it could improve workflows at scale — to truly bridge these worlds and translate between them instead of isolating or replacing them.

MCP changes this

MCP introduces a shared operational layer between stakeholders, tools, systems, and AI. Instead of design tools and coding tools operating in isolation, MCP allows AI to understand context across both environments and interact with them in a structured way. Design files, codebases, APIs, documentation, and product systems can all become part of a connected ecosystem.

One of the biggest values MCP brings is speed.

In the past, we created systems that gave structure and consistency, but ultimately slowed teams down. We spent a tremendous amount of time translating components, syncing documentation, updating APIs, aligning naming conventions, and still it was never good enough, let alone perfect.

MCP is here to change that. This is not a future concept, this is becoming available right now.

With Figma’s latest MCP updates, design changes can propagate more quickly into code, and code can be translated back into design. This becomes a two-way system, coordinated by MCP and directed by humans through AI agents. These agents help align systems, document changes, and keep everything consistent as the product evolves.

Moving through long chains of handoffs starts to look like a legacy process that organisations will gradually transform or phase out.

This doesn’t mean products are built instantly. It means the friction between steps is greatly reduced.

And when friction disappears, speed increases naturally.

Convergence of roles

In the past, coding tools were largely the domain of developers, while design tools belonged to designers. Each role had its own environment, language, and workflow. Collaboration happened through handoffs and communication rather than through shared systems.

MCP begins to blur these boundaries.

Design tools are becoming more connected to implementation. Coding tools are becoming more aware of design and user experience. AI sits between them, understanding both visual intent and technical structure, helping translate and execute work across environments.

This creates a shared space where designers and developers operate within the same ecosystem rather than in separate worlds.

Figma’s recent direction around MCP highlights this transformation clearly. By embracing MCP-based workflows, Figma is moving beyond being just a design platform and becoming part of a connected product environment. Design files are no longer static artifacts that need to be handed off and rebuilt. They become part of an executable system that can interact with code, product logic, and AI-driven workflows.

Design becomes more than representation. It becomes part of implementation.

This reshapes the design workflow itself. Instead of designing in isolation and passing work downstream, designers are working within a system that directly connects to development environments and product infrastructure. The design tool becomes an active participant in the product lifecycle rather than a starting point that gets translated later.

The uncanny valley begins to close

Importantly, MCP is not about replacing designers or developers. It is about removing the repetitive and mechanical work that sits between them. The goal is not automation for its own sake, but smoother collaboration and faster movement from idea to reality.

Designers still shape experiences. Developers still build systems. Product teams still define direction. But the manual coordination that once slowed everything down starts to fade into the background.

AI handles the connections. Tools stay aligned. Systems communicate.

What remains is the creative and strategic work that humans do best.

In the bigger picture, MCP represents a quiet but meaningful shift in digital product development. It turns disconnected tools into connected systems, replaces manual handoffs with continuous workflows, and reduces friction between design and implementation. As more tools adopt MCP and integrate AI more deeply into their workflows, the boundaries between stakeholders will continue to shrink.

Welcome to a new chapter — where hype turns into meaningful and productive use of AI, and where it finally starts driving real outcomes for organisations.