The EPD Collapse and the Rise of the Bilingual Architect

The EPD Collapse

We are moving from a world where implementation was the bottleneck to a world where review is the primary differentiator. When coding agents make execution cheap, the traditional EPD (Engineering, Product, and Design) waterfall collapses into a single loop.

From Implementation to Arbitration

Traditionally, building software followed a linear path: PRD → Mock → Implementation. Because turning an idea into code was expensive and time-consuming, we created specialized roles to manage each stage.

Coding agents change the physics of this process. If an agent can generate a functional prototype in seconds, the cost of “doing” drops to near zero. The new bottleneck isn’t implementation — it’s arbitration. The role of the human moves from the assembly line to the reviewer’s desk.

Builders vs. Reviewers

As roles blend, two distinct archetypes are emerging:

1. The Builder: A generalist who leverages agents to move from idea to production in hours. They have strong product sense, enough design intuition to steer the agent, and the technical literacy to prompt effectively. Within a guarded system (test suites, component libraries), the Builder is a one-person EPD team.
2. The Reviewer: A systems thinker who acts as the final filter. For complex features, the Reviewer ensures that agent-generated code isn’t just functional, but well-architected, scalable, and intuitive. The bar for this role is higher than ever — you need to navigate the system’s logic at the speed the agent produces output.

The Bilingual Architect

The post-agent “unicorn” isn’t just a coder who knows Figma. It’s someone who sits at the intersection of cultural currents (what the user actually needs, what feels inevitable) and deep technology (what is architecturally sound and technically possible).

This combination is what separates products that feel “assembled” from products that feel “inevitable.”

What This Means for Me

For my own work, this validates the “Unix-for-AI” approach — building the arbitration pipes rather than autonomous black boxes. By automating the implementation layer through agentic orchestration, you eliminate the communication overhead that slows down traditional teams. A single architect can maintain the systemic integrity of a large technical output with the precision of a dedicated reviewer.

In a world of cheap code, the most valuable asset is clear architectural thinking.

Inspired by Harrison Chase’s insights on the changing landscape of software engineering.