The Design Desk: an agentic design workflow at Huma

Names, links, ticket numbers and anything clinical are removed or changed. The screens are real captures from the canvases, the board and the repo, with demo data.

The Design Desk in 75 seconds. The process, the agents and what changed, with sound designed for it.

The challenge

A hundred stories a quarter, and no room to guess

Huma builds UK Primary Care, software for NHS GP practices: the inbox where patient requests land, triage, messaging and appointments. In Q3 the product team wrote 33 PRDs with 266 numbered decisions and asked for 90 design tasks. Q4 added 18 more PRDs and 98 stories. Two designers drew all of it.

Speed was only half of it. In healthcare, a wireframe that invents behaviour can ship a rule nobody decided. It happened once in Q3: a control that could write to a patient’s consent record made it into a design, and was caught only because a developer asked what to store.

One early brief came back with fourteen invented states where six honest ones were needed. The team’s own write-up put it plainly: the cause wasn’t carelessness, it was the format.

The other half was attention. Every open question either waited for the product owner or got answered quietly in a wireframe, where nobody would notice until it shipped.

Every state needs a source

A PRD line, a numbered decision or an acceptance criterion. A brief can rule something out. It can’t put something on screen.

Two design systems

Patient screens on the NHS design system, 390px first, WCAG 2.2 AA. Staff screens on a Material 3 kit at 1440px.

One person approves

The product owner’s attention is the bottleneck, so a question has to arrive researched, with options and a recommendation.

Version one · Q3 2026

A design loop inside git

The first version lived in the product team’s repo, next to the PRDs and decisions. Claude Code did the reading and the drawing through a set of skills and agents, and pull requests carried both the designs and the decisions.

My design track

The brief pack the first stories were drawn from
Before/after sheets: every state beside what it replaces, with its source
Handoff slices: one standalone file per story, every state one click away
Task audit: a ticket in, a change list out, each change citing its line
Handoff slicer: cuts a story’s screens out of the built prototype

The loop the team built around it

A desk that sent work to agents, each in its own git worktree
A decision helper that researched open questions and opened decision pull requests
A cold-read reviewer in a fresh context
A 14-check gate, lint scripts and CI on every design pull request

A Q3 handoff slice: the staff inbox with a care request open, rendered from the story’s standalone file — A Q3 handoff slice: one standalone file per story, here the staff inbox. Demo data.

A Q3 before/after sheet: a list of states, the AFTER frame and the changes, each with its source — A Q3 before/after sheet. Every change carries its source; the list on the left steps through the story’s states.

76Stories designed and filed in git as deliverables

337Pull requests merged in four months

91%Of commits co-written with Claude

6 daysMedian from a brief to its first deliverable

What broke

The cost moved from drawing to everything around it

By September the loop worked, and it was heavy. One batch review, nine stories over a week, counted 38 pull requests, about twenty worker agents, 23 worktrees left on disk and seven clashing question numbers. Its conclusion:

“Nothing in the cull touches what produced the designs; all of it touches what was spent checking, recording and renumbering around them.”

Wrong drawings found by cold reads

Seven cold reads, about 90k tokens and five minutes each, found nothing wrong. None.

All

Of the product owner’s findings were absences

Nothing was drawn wrong. Things were missing: a state, a failure, a permission.

18 of 22

Sheet and slice pairs had lost their markers

13 of 21 on a stricter count. The two files were made separately, so open-question markers went missing without anything noticing.

Merges in September needed conflicts fixed

Most were in the one shared question file that every agent wrote to.

Q3 · made by hand, one file at a time

Handoff note

Before/after sheets

SliceMarker lost

Q4 · generated from one record

story.json

Cover

Before/after sheets

Slice

Hand-made files drift apart. Files generated from one record can’t, because there’s only one place to change.

Decision log

Seven decisions for version two

I took those findings and redesigned the loop from scratch. Each decision gave something up.

01Git for knowing, canvases for drawing

Context: Designs in git meant pull requests for files nobody could review as a diff, plus worktrees and locks so agents wouldn’t collide.
Options: Keep everything in git · move everything into a design tool · split by job
Trade-off: Two places to keep straight, and design history that lives outside version control.
Outcome: PRDs, decisions and questions stay in git and change by pull request. Drawings live on Claude artifact canvases. Nothing designed goes to git.

02One record generates every handoff file

Context: Sheets and slices were authored separately and drifted.
Options: More checks on hand-made files · generate every file from one source
Trade-off: The record has to be strict. The generator refuses a state without a citation, a prop the surface doesn’t declare, or an open review item.
Outcome: A script with no model writes the cover, the slice, the before/after sheets, the notes and the state boards from one story record, then renders and checks every sheet.

03Check once, and look for what’s missing first

Context: Cold reads found nothing wrong, and the product owner’s findings were all absences.
Options: Keep repeat reads and the 14-check gate · one strong checker, run once
Trade-off: One pass has to count: a strong model, a fresh context, and no view of the drawer’s chat.
Outcome: Missing first, then invented, contradicted, drawn differently and off the design system.

04Cheap models read; strong models draw and judge

Context: Grounding a story means reading a lot. Drawing and checking need judgement.
Options: One strong model everywhere · a tier for each job
Trade-off: Agents hand work to each other, so every brief between them has to fit in ten lines.
Outcome: Researchers on a cheap model, the drawer and the checker on a strong one, the generator on none at all.

05Research every question before a person sees it

Context: The product owner’s attention was the bottleneck.
Options: Ask everything · decide in the wireframe · research first, then route
Trade-off: An undecided state ships as a labelled placeholder until someone answers.
Outcome: A decision helper settles what the sources already answer. Designer’s calls come with options and a recommendation. Only consent, safety, the patient record and billing go to the product owner, in one pull request per task.

06One workspace per story, promoted on approval

Context: Two designers, and many stories changing the same surfaces at once.
Options: One shared canvas · branches and locks · an isolated workspace per story
Trade-off: Copies to keep in step. A story built on another is brought up to date with a three-way merge, and a conflict stops for the designer.
Outcome: The product hub changes only on approval. Twenty of the first 37 stories were built on another story, up to five deep.

07Draw only from the design systems

Context: Hand-built parts drifted from the kit. As one review put it, correct and inconsistent is still a defect: a developer building it gets two components.
Options: Allow small hand-built parts · kit components only
Trade-off: A missing component blocks drawing until the design system has it.
Outcome: Kit component first, then patterns, then the shell, with no raw colour, spacing or type. A missing component becomes a finding for the design system.

Version two · Q4 2026

A desk of agents, and three stops for people

A designer opens one chat per story and gives the desk its key. The desk works out where the story is, runs the next step with the right agent and stops whenever a person has to decide. It orchestrates. It doesn’t draw, and it doesn’t decide.

Git · what we know

Read

Make and check

Canvases · what we draw

Hover or tap a part to see what it does and what it talks to.

Nine steps, three of them for people

One story, nine steps

Git: what we knowPRDs, decisions and open questions. Answers land by pull request. Nothing designed goes to git.

Canvases: what we drawOne workspace canvas per story, promoted into the product hub and its area’s state board once approved.

01 · Ground

Read everything before drawing anything

A researcher agent on a cheap model reads the Jira card, the PRD, the decisions and the brief, then sweeps every canvas for parts that already exist. It writes the story record: each state with the line that asks for it, what gets reused, what stays out and what nobody has decided yet.

In: Jira card, PRD, decisions, brief
Out: The story record, version 0

RuleEvery state cites a PRD line, a decision or an acceptance criterion. A brief can forbid things; it can’t authorise them.

Story recordA real Q4 story

ChangeThe settings row now opens its sectionPRD 45 · decision 13
AddThe library as it ships this quarterPRD 38 · decision 8
AddA maintained row offers no edit, copy or retirePRD 38 · What must be true
DecideThe sign-off line on a rowOpen question · Q-2

7 of 10Parts reused or adapted from the hub

18Not drawn, each with an owner or reason

8Open questions

02 · Ask

Ask before drawing, one question at a time

Every open question goes to a decision helper first. It searches the PRD and decision notes, then NHS England and ICO guidance, then peer products. Settled questions get dropped. The rest come to the designer one at a time, with options and a recommendation, and every answer is recorded in git.

In: The record’s open questions
Out: Answers recorded in git

RuleWhen two approved sources disagree, the story stops. Nobody quietly picks one.

Question Q-5Designer’s call

No source gives a row order. Which order should the list use?

Maintained rows first, in the PRD’s family orderRecommended. Stable, with no recency.

AlphabeticalMixes the two owners together

Most recently used firstThe PRD keeps recency for the composer

1Answered by the sources

4Designer’s calls

3To the product owner

The same story’s eight questions. Anything touching consent, patient safety, the record or billing goes to the product owner.

03 · Workspace

A private canvas for every story

The desk agent opens a new canvas with the four design systems installed, copies in the surfaces the story changes and freezes a BEFORE copy of each. If another open story already changes the same surface, the new one is built on top of it and kept in step with a three-way merge.

In: The surfaces the story changes
Out: A workspace with frozen BEFORE copies

RuleWork happens on the workspace. The product hub changes only after approval.

04 · Draw

Draw each state from the kit, nothing by hand

The drawer agent, on a strong model, adds each state to its surface as a scenario preset, built only from design-system components and tokens. When the kit lacks a component, that goes back to the design system as a finding instead of being hand-built on the surface.

In: The record and the workspace
Out: Every state as a scenario on its surface

RuleNo raw colour, spacing or font size that isn’t a token.

05 · Generate

One record makes every handoff file

A script with no model builds the cover, the handoff slice, the before/after sheets, the notes and the state boards from the one story record. Sheets are rendered and checked headlessly, and any lint error stops the run. Nobody edits these files by hand, so they can’t drift apart.

In: The story record
Out: Five handoff files, always in sync

RuleNever hand-edit a generated file. Change the record and run it again.

06 · Check

Look for what’s missing first

A checker agent with a fresh context reads the design once. First it looks for what’s missing, then anything invented, contradicted, drawn differently from its source or off the design system. In one review batch, every finding the product owner raised was something missing, so absences come first.

In: The drawn workspace and its record
Out: Findings, each tied to a state

RuleEach state covers permission, validation, loading, empty, failure, recovery, expiry and concurrency, or says why it doesn’t.

Checker, round 07 findings · all applied

MissingThe AFTER frame repeats BEFORE, so the opened section isn’t shown
InventedNothing found
ContradictedTwo decisions marked provisional had already been approved
Drawn differentlyPlaceholder rows don’t use the PRD’s own words
Off the design systemA placeholder box built by hand with raw sizes

07 · Review

Review comments become the to-do list

The designer reviews on the canvas. Each comment becomes a round item, word for word, gets fixed, and the files are generated again. Draw, generate and check repeat for as many rounds as it takes, until the designer says it’s done.

In: The checked workspace
Out: Applied rounds, logged in the record

RuleComments are kept verbatim. The record holds the history, not anyone’s memory.

Designer roundsKept word for word

r2.1
“Make the height of all these pages fit the content inside them.”
AppliedEvery state board and BEFORE frame now takes its content’s height, measured headlessly.
c1.2
“Mount NHS TextInput for the pre-filled text field … drop the hand-built input.”
AppliedThe field is the kit’s TextInput, so its error states work too.

From a real Q4 story: one comment on the canvas, one during the checker’s round.

08 · Approval

One place for the product owner to look

Every task has one pull request for the product owner, holding its questions, the request to approve and the outcome. When the designer says done, the task is marked ready on the Design Progress board. The product owner approves there, or sends it back with a note and another round begins.

In: A task the designer has signed off
Out: Approved, or sent back with a note

RuleOne task, one pull request. A designer’s own call never goes there.

09 · Promote

Promote the work, then close the workspace

Once approved, the desk agent moves the surfaces and the handoff into the product hub and puts every state, with its note, on its area’s state board. Jira gets the link after I confirm, and the workspace closes.

In: An approved workspace
Out: An updated hub and state boards

RuleA promotion isn’t done while any state is missing from its area board.

Step 1 of 9Ground

Huma · UK Primary Care · Design kit v1 UK Primary Care Design Playbook

How a story goes from a Jira card and a PRD to an approved design, with agents reading, drawing and checking, and people answering and approving.

Two places, two jobs

Git · what we knowPRDs, decisions, questions, briefs

The knowledge base. The decision helper records answers by pull request, and the product owner approves by merging.

Artifacts · what we drawHub, area canvases, workspaces, design systems

Each story is drawn in its own workspace canvas, promoted into the hub on approval, and the workspace closes.

RuleNothing designed goes to git.

One story, nine steps · pick one below

Groundresearcher · cheap model

Agent

Reads Jira, the PRD, decisions and the brief, then searches every canvas for parts that already exist. Writes the record: each state with its citation.

Agents read, draw and check. People answer, review and approve.

Tasks built on tasks

Task B · built on A v3Changes the same surfaceCopies it from task A’s workspace, not the hub’s older copy

Task A · v3Waiting for approvalEvery change bumps its version

RebaseWhen A changes, the desk merges it into B with a three-way merge.
ConflictA clean merge carries on; a conflict stops and asks the designer which version wins.
OrderThe board flags a task that is behind. A is approved and promoted first, or the stack together.

Start a session · the one prompt

Read kit/BOOT.md, kit/README.md and kit/RULES.md from the Design Playbook artifact, run its First session checks, then run kit/skills/atlas-desk.md for story <KEY>. Talk to me in my language; everything inside the design stays English.

First session · stops at the first check that fails

GitHubThe knowledge repo can be read
JiraThe connector reaches the project
ArtifactsThis page, the progress board and the hub are shared
Daily checkIts own routine, every weekday and on Sync now

Desk ready · story Q4-177

The canvases · who writes where

Design ProgressLive board: every task and which step it is onthe desk, after every step
HubOne copy of every surface, plus a handoff page for each setpromotion only
State boardsOne per area. Every promoted state sits here, with its notepromotion only
WS · <KEY>The isolated workspace for one story, closed after promotionthe drawer
Design systemsMaterial 3, shell, patterns, NHS: the only source of componentschanged there, then reinstalled

What carried over from Q3, and what didn’t

Kept

Ask before drawing. Never redraw a part that exists. Every state cites a PRD line, decision or criterion. The product owner’s words, verbatim. Cheap models read; strong ones draw and judge.

Dropped

Pull requests for designs, worktrees, locks, the 14-check gate and repeated cold reads. A review measured zero wrong drawings found by repeat reads.

New

One record generates every handoff file, so the slice and the sheets can’t drift. The checker looks for absences first: every finding in that review was something missing.

The kit behind the page

kit/BOOT.mdFirst-session checks, then the hand-off to the desk
kit/README.mdHow the desk works, end to end
kit/RULES.mdThe rules every agent keeps
kit/agents/roles.mdWho reads, who draws, who checks, on which model
kit/skills/atlas-desk.mdThe desk: runs a story through all nine steps
kit/skills/atlas-ground · ask · workspace · draw · check · review · promoteOne skill per step
kit/scripts/atlas.mjsGenerates the handoff from the record, lints, rebases
kit/schema/story.mdThe shape of the one record
kit/examples/story.jsonA finished record to copy from

Agents run six steps three wait for a person: an answer, a review, an approval

The playbook is the handover. Open any section: whoever designs next shares this page, pastes one prompt, and their Claude checks its own access and sets itself up from the kit behind it.

The desk at work

One story, start to finish

Here is one real Q4 story, a list of questionnaires inside Practice settings, from the designer’s chat to the board the product owner approves on.

It asks before it draws

Every message that moves a story opens with a one-line progress bar. Every question comes with options and the recommended one first, so a decision takes a click, not a meeting.

Q4-177 · Questionnaire library

/atlas Q4-177

Q4-177 ✓ Ground ✓ Ask ✓ Workspace ✓ Draw ✓ Generate ✓ Check ● Review ○ Approval ○ Promote

Check is done. The checker raised 7 items and all 7 are applied: the AFTER frame now shows the opened section, placeholders use the hub’s DECIDE box, and the three open questions link to the product owner’s pull request.

Five states are on the canvas with their notes, the slice and the before/after sheet. It’s with you for the design review.

Ran the checkerApplied round 0Regenerated 5 files

Review

How does the canvas look?

Done: ready for the product owner (Recommended)Marks it ready on the board and adds the approval request to its pull request

I have correctionsComment on the canvas; each comment becomes a round item, word for word

DeferLeave it in review

Redrawn from the desk’s real message format. The details come from a real Q4 story: its record lists eight questions, of which one was answered by the sources, four were the designer’s calls and three went to the product owner.

One record, five files

The researcher writes the story record before anything is drawn: each state with the line that asks for it, what gets reused, what stays out and what’s still open. The generator turns that one file into everything the team opens.

{
  "key": "Q4-177",
  "status": "ready-for-review",
  "states": [{
    "id": "library-shipped",
    "kind": "ADD",
    "label": "The library as Q4 ships it",
    "cite": "PRD 38 d8; PRD 37 line 39",
    "before": { "surface": "Before_PracticeSettings" }
  }, … 4 more],
  "notDrawn": [18, each with its reason or owner],
  "questions": [8, answered or sent to a PR],
  "rounds": [{ "by": "checker", "items": 7, "applied": 7 }]
}

CoverStart here: states, open questions, rounds
Handoff sliceEvery scenario one click away
Before/after sheetsNumbered changes on both frames
NotesOne per state, with its sources
State boardsFiled by product area

Everything on one canvas

One story’s workspace canvas: the frozen BEFORE, the cover, the handoff slice, two states with their notes and the before/after sheet

Drag to explore the canvas

Real boards from one story’s workspace, in the order the generator lays them out: the frozen BEFORE, the cover, the slice, each state with its note, and the sheets.

The handoff engineers open

The generated handoff slice: a control card with scenario chips, the state’s note and sources, the not-drawn list, and the live screen below — The slice. Scenario chips switch the live screen; each state shows its kind, its note and its sources, and the eighteen things deliberately not drawn are listed with their owners.

A generated before/after sheet: BEFORE and AFTER frames with numbered outlines, and a numbered list of changes with sources — A sheet. Numbered outlines are baked in and checked: a mark that’s missing, ambiguous or off its element stops the generator.

A checker that looks for what’s missing

The checker reads the PRD and the brief itself and never sees the drawer’s chat. It reports in a fixed order, absences first, and anything it can’t cite it doesn’t report.

235Findings across 27 stories

8Median per story, from 4 to 16

13Stories where nothing was invented

What the checker found, by kindSix stories with a full breakdown · 57 findings

Missing19

Sheet or record out of step16

Off the design system8

Drawn differently from its source6

Contradicts a source5

Invented3

Show as a table

Kind	Findings
Missing	19
Sheet or record out of step	16
Off the design system	8
Drawn differently from its source	6
Contradicts a source	5
Invented	3

MissingThe AFTER frame showed the same picture as BEFORE, though the note promised the opened section.
Off the design systemA placeholder box was built by hand with raw sizes, while the hub already had the same open-question box.
Contradicts a sourceTwo decisions were listed as provisional, though the product owner had already amended and decided both.

One place for the product owner

Each task has one pull request for the product owner, holding its questions, the approval request and the outcome. The board shows every story’s step and who it’s waiting on; approval is one button, or a note that sends it back.

The Design Progress board: 35 tasks in progress, 108 items waiting on the product owner, and a list of stories with a nine-step bar each — The Design Progress board on 14 October. Each row shows the story’s nine-step bar and who it’s waiting on.

A story open on the board: the approval card with Approve and Send back with a note, and the nine steps with dates and notes — One story open: the approval card, and every step with its date and what happened.

Stories built on stories

When a new story changes a surface an unapproved story is still changing, it’s built on top of it. Each change underneath bumps a revision, and the desk brings every story above it up to date.

Each question type, shown accessiblyrev 2
Answers, files and lookups refusedrev 1 · built on rev 2
A pre-filled answer, marked as suchrev 3 · built on rev 1
The point a branch changed the questionsrev 1 · built on rev 3
Progress through the journeyrev 1 · built on rev 1

A real stack, five deep, on 14 October. A clean three-way merge carries on; a conflict stops, and the designer picks which version wins. That day three other stories sat behind their parent, each flagged on the board with “bring the change in”.

Every bug became a check

In its first week version two drew dozens of stories, and some came out wrong in the same way more than once. I didn’t fix them one by one. Each kind of mistake became a check the generator now runs every time.

A “new” BEFORE where an old screen existedBEFORE now comes from the truest source there is, down to the old Figma frame, and each change points at the region it replaces.

Dialogs missing from AFTER framesFrames are pinned to their board’s size, and the sheet check renders each one as the canvas does and fails a dialog outside it.

Change rows describing an earlier draftA row compares BEFORE with AFTER, never with a draft, and the checker reads the sheet once.

Marks on the wrong elementA mark whose words match more than one place has to say which; the sheet check fails it otherwise.

Note boards the wrong heightEvery note is rendered and its board fitted to the measured card; a note with more than 8px to spare fails.

All

Impact

Faster, and every state on the record

Stories signed off by the designer, per dayVersion two’s first eight days, 7–14 October · 31 stories

27 Oct

28 Oct

39 Oct

410 Oct

011 Oct

1712 Oct

213 Oct

114 Oct

Show as a table

Day	Stories signed off
7 Oct	2
8 Oct	2
9 Oct	3
10 Oct	4
11 Oct	0
12 Oct	17
13 Oct	2
14 Oct	1

3 days

The pilot set, end to end

First read to promoted, through review and approval

Two Practice settings stories were grounded on 6 October, signed off on the 7th, approved on the 8th and promoted on the 9th.

5.5 h

Record to sign-off, median of 15 stories

The fastest took 70 minutes

Measured from the accepted record to the designer saying done. In Q3 the median from a brief to its first deliverable was six days. They’re not the same measure, but the gap is the point.

Same day

Time to ask a question

Down from 21 days in August

The median time from raising a question to putting it to someone fell to one day in September and the same day in October.

7 in 10

Questions settled before the product owner

About 223 settled, 89 sent on

Settled from the sources or by the designer. What reached the product owner touched consent, safety, the record or billing.

350

States on the area boards

Every promoted state, with its note

Filed by product area, from the inbox to patient screens, so the next story starts from what’s already decided.

The playbook is written so whoever designs next starts from one prompt, and the rest of the organisation is now moving to the same way of working.

What I’d change. Drawing got fast enough to move the queue: by mid-October, 29 stories were waiting for approval. The next version has to make approving as cheap as asking already is.

Reflection