There’s a wall inside most product teams that nobody talks about as a wall. It lives in the moment a Figma file gets “handed off” to engineering. A designer finishes a prototype, attaches it to a Jira ticket, writes a spec, and waits. The engineer picks it up two days later, interprets it, finds gaps, sends questions back. The designer is already on another task. Context is gone. The engineer ships something close enough.

That wall is invisible because it’s built into the process. Everybody accepts the three-day delay as normal because it’s always been that way.

Teams at Figma and OpenAI ripped it out. And the way they did it has a name borrowed from 1970s football.

Total football, applied to product

In 1974, the Netherlands national football team walked into the World Cup with a system called totaalvoetbal — total football. Every outfield player could play every position. When someone moved forward, the rest covered. No fixed defenders chained to a zone. The team was so fluid that in the final, Johan Neeskens scored within sixty seconds. Before any German player had touched the ball.

They lost 2-1 to West Germany.

The most revolutionary tactical system football has ever seen didn’t win the tournament where it debuted. Keep that in mind.

Aakash Gupta drew this exact parallel a few days ago when describing how product teams at Figma and OpenAI work. Designers ship code. PMs prototype in production. Engineers pull designs into Figma with a single MCP command. When someone is out for a day, someone else picks up their lane.

Ed Bayes, product designer on OpenAI’s Codex team, said in the conversation that 70-80% of his time as a designer is spent coding. A content designer on his team ships pull requests to production. Her job title is still UX copy.

Gui Seiz, Director of Product Design for AI at Figma, describes his teams as people with deep spikes in one area but no fixed territories. The boundaries between roles get crossed in minutes, not sprints.

The Figma 2025 Shifting Roles report backs this up with numbers. Sixty-four percent of respondents cross role boundaries regularly. Fifty-six percent of non-designers participate significantly in design tasks.

The org chart didn’t change. Designer, engineer, PM. The actual workflow looks nothing like it. And it looks a lot like what happened when the software development lifecycle collapsed — the phases merged, but the job titles stayed the same.

The tools that killed the handoff wall

This isn’t happening because of a culture memo. It’s happening because the tools removed the technical barrier to crossing.

Figma MCP makes the flow between design and code bidirectional. An engineer pulls a design from Figma — with its variables, tokens, components, layout rules — and turns it into working code without interpreting a screenshot. A designer pushes a prototype so technically accomplished it would have needed a full engineering sprint six months ago.

Design systems ride along as a productivity multiplier. The design system’s rules travel with the components. The AI agent doesn’t guess the styles. It reads them straight from the file.

On the OpenAI side, Codex integrates with Linear and Slack. You assign it issues directly from the project board. It’s not an assistant that suggests code. It’s a teammate that gets assigned tasks.

Aakash nailed the summary: “Three people with overlapping capability and different judgment.” Nobody does everything. But when somebody needs to cross into the next lane, the crossing takes minutes instead of a week-long ticket queue.

That’s the real multiplier. It’s not a better model or a new framework. Handoff friction dropped to zero.

Holland lost the final

Here’s where the analogy gets uncomfortable for the people who only heard the pretty part.

Holland lost the 1974 final to a West Germany team that played with far more defined roles. The Dutch had crushed everyone on the way — 4-0 against Argentina, 2-0 against Brazil, the reigning champions. But in the match that counted, they lost.

Total football demands two things that rarely get mentioned together: extraordinary talent at every position and clear coordination of who covers whom when someone moves. Without both, what looks like fluidity is chaos wearing a nice kit.

Product teams fall into the same trap. When someone announces “everyone here can do everything,” the question nobody asks is who decides when there’s a disagreement. A designer prototyping in production and an engineer editing in Figma sounds great until a design change breaks the architecture and nobody knows whose call it was to ship it. Accountability dissolves the moment role boundaries blur without a clear framework for who owns which decisions.

Org structure exists for a reason beyond bureaucracy. It’s a system for resolving conflicts between people who want different things. I wrote about this when I analyzed why your AI agent directory is not an org chart: structure doesn’t disappear because the tools got better. It adapts.

The teams that actually work kept the roles but tore down the walls separating them. Those are very different moves.

Role fluency, not role elimination

The pattern that actually works resembles the 100x employee: one person with cross-disciplinary capability who operates across the full problem surface, but who owns a clear primary accountability.

A designer writing code doesn’t stop being the user’s advocate — that stays the job regardless of which tool is open. Same with the engineer who spends mornings in Figma: when the system goes down at 3 a.m., they’re the one getting paged, not the PM who built the last prototype.

The real distinction is between “everyone does everything” and “everyone can cross when it matters.” The second version only works when people know whose judgment wins on each type of call.

We built the Jira handoff wall to cope with the weeks it used to take to move work between design and engineering. As the technical friction of crossing drops toward zero, the need for that wall vanishes on its own.

Gui Seiz’s approach at Figma: hire for spikes (real depth in one area), enable crossing (tools plus culture), and preserve judgment boundaries. Nobody tells the designer to stop advocating for the user. They give the designer the tools to get that advocacy into production without waiting in a queue.

What it takes to play total football without losing the final

Total football in product teams is not a tools problem. It’s an organizational design problem.

The tools need to actually let people cross natively — MCP, Codex, agents that bridge disciplines. If your designer still needs an engineer to “translate” prototypes into code, you’re passing tickets under a different name.

But tools alone get you nowhere without clear ownership of decisions. Fluid roles are fine. Fluid judgment is a disaster. You still need definitive owners for user experience, system architecture, and product direction. When those lines go blurry, you end up with half-finished features that nobody is responsible for.

And just like Holland had Rinus Michels coordinating who covered whom in 1974, your team needs an orchestration layer — a role, a process, a coordination system — that sees the full field. Without it, the fluidity turns into improvisation.

Adopting Figma MCP or ripping out the Jira board accomplishes nothing on its own. The teams that ship circles around everyone else combine the fluid capability with clear ownership of judgment calls.

At IQ Source we design that middle layer. We evaluate how your teams are crossing roles today, where fluidity is creating real velocity and where it’s creating hidden decision debt, and we deliver a role and tooling design that enables the crossing without losing accountability. If your team already has the tools but the speed hasn’t changed, the bottleneck isn’t technical. It’s organizational. Let’s talk.