Track / Workflows
How components actually move from idea to production in 2026 — the four-stage spine (RFC, design review, tech review, ship), where AI agents enter each stage as assistance, and the surfaces reviews now happen across (Figma frames, MCP context, PR diffs, component stories).
01 / The shift
Workflows used to be a calendar of meetings — sync RFC review, sync design crit, sync tech review, sync ship. The 2026 default is artifact-driven: RFC is a doc, design review is annotations on a Figma frame, tech review is comments on a PR, ship is a merge. Synchronous time goes to disagreement, not status.
Design crit Mondays, eng review Thursdays, ship meeting Friday. The meeting was the artifact.
Async RFCs in Notion or Confluence. Comments instead of meetings. Status pages and project boards.
RFC, Figma frame, PR, codemod, story — every stage has a permalinked artifact. Agents grade the artifacts; humans review the agent.
02 / The pipeline
Three phases, one artifact carried the whole way. Each phase produces a permalinked deliverable the next phase consumes — no re-drawing, no re-specifying.
03 / The spine
The spine doesn't change. What changes is what each stage produces — and the artifact that survives after the meeting (if one happens) is over.
Revise & re-enter · median: two passes
Most RFCs iterate at least once — the loop is the default
1–2 weeks
A short written proposal — problem, motivation, the shape of a solution, alternatives considered, and what success looks like. Lives in a doc, not a meeting.
3–5 days
The proposed visual artifact gets checked against the system: token contract, density, motion vocabulary, accessibility floor. Happens against the Figma frame and the MCP context, not on a Zoom call.
1 week
Engineering feasibility, API surface, performance impact, and the codemod plan. The codemod ships with the review: if a change can't be codemoded, the change gets reshaped.
2–3 days
Final sign-off, PR opened, codemod published, changelog entry written, consumer teams notified. Adoption tracking begins on day one.
04 / Human and agent
Agents draft, surface, run, and post. The human owns the artifact, the decision, and the consumer-team conversation.
01
RFC draft
Frames the scope
Drafts from brief
02
Design review
Decides the tokens
Reads the frame
03
Tech review
Owns the API
Writes codemod
04
Ship
Approves merge
Opens the PR
Where AI agents enter each stage — assistance, not authorship
Frames the problem, names the constraints, decides the success criterion. Sets the scope.
Drafts the structure from the brief, fills in alternatives-considered, finds adjacent prior art in the system's history.
Decides whether the proposal earns a place in the system. Final say on token contract and pattern fit.
Reads the Figma frame via the Dev Mode MCP. Flags off-token values, missing motion vocabulary, contrast violations.
Owns the API shape and the migration narrative. Sets versioning and the deprecation window.
Writes the first draft of the codemod. Runs it across the consumer-team repos to surface edge cases before review.
Approves the merge. Owns the announcement copy and the consumer-team conversation.
Opens the PR with the component, story, docs, and codemod. Posts the structured changelog entry.
05 / Where review happens
There is no single review meeting. There is a stack of surfaces, each holding part of the artifact. Reviewers move across the stack; the decision falls out when the surfaces agree.
where the artifact merges
Reviews happen across surfaces — Figma, MCP, PR, component story
Source of intent. Variables and component graph readable via the Dev Mode MCP server.
Figma Dev Mode MCP + the system's own MCP. The agent grounds its work in both.
Where consequence-conversations happen now. Comments, codemod results, CI checks all converge here.
Storybook or Ladle. The same surface designers spot-check and engineers wire up.
06 / Watch out for
Five failure modes that show up within the first year of running the four-stage spine with agents in the loop.
A proposal that doesn't name the codemod is a wish list. The codemod plan is part of the RFC, not a follow-up.
Synchronous reviews don't scale and don't leave a trail. Reviews happen against the PR and the Figma frame — both have permalinks.
Agents write codemods, draft RFCs, propose API shapes. Humans still own the decision and the artifact. The agent's output is the first draft of one section, not the spec.
Major-version cuts, breaking renames, sunset announcements need a written cooling period — 48 hours minimum between the proposal landing and the merge.
Single-reviewer approval lets institutional knowledge calcify in one person's head. Pair reviews are cheap insurance.
07 / Signals of a healthy workflow
Five signals you can check this quarter. If none are true, the workflow exists on paper only.
