Executable Collaboration
A code-based framework for design × engineering
- Role
- Framework author and designer
- Timeframe
- Active working model, now in pilot
- Status
- In use by one team, piloting with others
- Scope
- Workflow, tooling model, decision records, adoption
Mandate
Identified the same collaboration failure across two separate research moments, then designed the framework, review model and adoption path now piloting beyond my own team.
The pattern had been there for years
Design and engineering were working on the same product, but not in the same system.
An internal engineering study in 2022, and a cross-team workshop three years later, surfaced the same five problems regardless of team or tooling: unclear source of truth, late feasibility discussions, incomplete documentation, design-system drift and low visibility into change.
Existing
- Design mockups
- Slack updates
Not yet connected
- Shared source of truth
- Feasibility review
- Change history
Changing the artifact, not the handoff
Before
The design artifact was a representation of the product.
After
The design artifact is a running version of the product.
A prototype now behaves like engineering work, on one loop reused for every change:
- 01
Design intent
- 02
Build
- 03
Commit
- 04
Pull request
- 05
Live preview
- 06
Review
- 07
Merge
Decision 01
Design directly in code
Designers work in code with AI assistance — not to become frontend engineers, but to make the interaction itself available for inspection much earlier. Complex states, responsive behavior and edge cases can be experienced rather than inferred from static frames.
Feasibility questions surface at creation, not after handoff.
Decision 02
Give every decision a record, not just the code
Running prototypes live in a shared Git repository, where changes have history and experiments happen safely on branches. Meaningful decisions are documented alongside the work through Design Decision Records, adapting the engineering pattern of Architecture Decision Records for design.
The repository captures both what changed and why it changed.
Decision 03
Make the pull request the collaboration object
The first version's review lived partly outside Git, which moved the original source-of-truth problem into feedback instead of solving it. Every pull request now generates a live preview, and design and engineering resolve feasibility and design feedback in the same thread.
Feedback becomes anchored to a version of the work, not a moment in a Slack thread.
Decision 04
Consume the real design system, not an imitation of it
A coded prototype is still unreliable if its components merely imitate the production design system. The framework consumes the actual design-system packages engineers use, so a production component change propagates into the prototype automatically.
A company that can't support this becomes visible immediately, instead of hidden behind accurate-looking mockups.
From my workflow to a team workflow
I identified the gap
This wasn't an AI problem. A 2022 engineering study and a 2025 cross-team workshop — different teams, different tools — surfaced the same structural collaboration failure, which is what justified building a framework rather than a better handoff habit.
The design crossed organizational boundaries
Adapting Architecture Decision Records into Design Decision Records, and getting AI-assisted communication to automate transcription without automating judgment, both required working directly with engineering's own conventions rather than inventing separate ones.
The model had to outlast the person who built it
The first version succeeded under unusually favorable conditions — I was already comfortable in Git with a close engineering relationship. A four-stage maturity model and an explicit pilot with less-favorable teams are how the framework is meant to survive without me operating it.
What Executable Collaboration became
The workflow, in production
Design intent becomes a running prototype in Git; every pull request opens a live preview; design and engineering review the same running interaction; a Design Decision Record captures why. This is the actual loop the team uses today, not a proposal.

What we know so far
Progression
Additional teams are adopting the workflow under deliberately less favorable conditions than the original one.
Three pilot measures defined
Design iteration cycle time, engineering visibility, and documentation overhead are baselined before adoption and re-measured during the pilot — the numbers are allowed to prove the framework wrong.
A four-stage maturity model
Static → Linked → Executable → Integrated. Teams can move toward executable collaboration incrementally rather than adopting everything at once.
Named, unresolved risks
Git fluency, discipline under deadline pressure, and tooling dependency are called out explicitly as open questions the pilot needs to test, not solved problems.