Generating a prototype is easy now. Making it carry design intent is the work.
Code prototypes can preserve layout, behavior, responsiveness, and component decisions that static files leave open to interpretation. Most Copilot-licensed designers on the team now work in code, and I am coaching all four peer leads across the 30-person design team.
A code prototype carries the decisions a static design file leaves open.
AI agents made working prototypes easy to produce, but Chase had no approved way for designers to publish them. Working code stayed on the designer's machine.
I lead the Home Lending program that helps designers use code as a design medium. The work spans coaching, shared standards, and the tools designers need to make coded prototypes useful beyond their own machines.
Design decisions discovered in code become the input to the build.
The designer directs an AI agent, and layout, behavior, and responsive decisions emerge.
Skills extract the decisions discovered in the prototype into human- and machine-readable specifications.
A code prototype only creates value when others can use it and its decisions survive the handoff. Without sharing and durable standards, the work stops at the demo.
Designers could run prototypes locally, but partners and stakeholders could not open them. Designers had to present the work live, which prevented others from exploring the interaction on their own.
Sharing was only half the problem. Without structure and extraction, design intent remained trapped in the prototype, and engineering partners had to reconstruct it before they could build.
Running code can still lose intent.
The team can see the result but cannot reliably recover the decisions that produced it.
Generating the prototype is no longer the hard part. The value lies in making its decisions clear enough for the next agent, engineer, and production stage to use.
Coaching helped designers begin working in code, but it could not keep standards consistent across people, projects, and agent sessions. I moved those standards into the workflow.
Embed the standard in the workflow
A packaged set of agent instructions—the design skill—applies our shared coding guidance whenever a designer works, while ESLint and Agent UI SDK checks catch incomplete or inconsistent output. I am teaching the same workflow to all four peer leads, so the quality bar does not depend on my presence in every session.
Coaching hardens into standards that run without me in the room.
Hands-on guidance helps designers start, but the standard fades between people, projects, and sessions.
Make prototypes shareable and reusable
Sharing and reuse required two different fixes. I built intent-extraction skills so engineering received explicit decisions instead of reconstructing them. I then worked with engineering partners to establish an approved publishing path that let stakeholders explore prototypes directly.
One design-through-making path produces two durable outputs.
Layout, behavior, responsiveness, and component decisions discovered through making.
One path serves two audiences. Partners can explore the working prototype now; engineering receives the design intent needed to build it later.
Make the practice portable
I packaged the coaching, embedded standards, extraction, and publishing model into a playbook so other teams could adopt the practice without rebuilding the infrastructure.
The practice is spreading beyond the people I coach directly.
- Most
- Building with agents in code.
- 4
- Receiving coaching on Claude Code, deployment, and operating practices.
- 2
- Used coded prototypes and the publishing infrastructure to share work with the CEO of Chase Home Lending.
The practice extends beyond my team now. Most Copilot-licensed designers build with agents in code, I coach all four peer leads, and two Home Lending teams have used coded prototypes and the design-owned publishing path to share work with the CEO of Chase Home Lending. A replication playbook is reaching the consumer Home Lending teams.
What I would do differently: build the deployment path before teaching the tools. Designers adopted agent-assisted coding quickly; what slowed them was having nowhere to put the result. The infrastructure was the enablement, and I would lead with it.
How do you keep a designer's intent intact once the prototype leaves their hands? If you're building the practice that makes that happen, let's talk.
Prime — Pricing PlatformThis case turns one designer's prototypes into a repeatable practice; Prime is the same leadership problem at project scale, where four designers replaced a business-critical pricing system.