Skip to content
Adila SadovicSenior Product Designer
WorkDesign systems & engineering workflow

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.

01Problem

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
static artifact

Not yet connected

  • Shared source of truth
  • Feasibility review
  • Change history
02What I changed

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:

  1. 01

    Design intent

  2. 02

    Build

  3. 03

    Commit

  4. 04

    Pull request

  5. 05

    Live preview

  6. 06

    Review

  7. 07

    Merge

One medium: five layers, a single loop from prototype to merge, and the production design system underneath all of it.Click to enlarge

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.

03Beyond the solution

From my workflow to a team workflow

01

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.

02

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.

03

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.

04After

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.

Diagram of the Executable Collaboration framework. Five layers — creation, source of truth, render and review, communication, and design system — sit beside a seven-step loop: design is executable, code with AI, commit, open PR, review in PR, merge, notify and digest. A design system foundation runs underneath every layer.
The five layers and the seven-step loop, as they run today — not a proposed model.
05Evidence

What we know so far

Progression

One teamMulti-team pilot

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.