mh studio Book a free call
← All work
$ cat case-study.md

draftboard_

A concept AI app builder where every change shows what was added and removed, in plain words first, and you accept or reject it. A builder web app, a mobile review app and a website, all working prototypes.

~/case/draftboard
$ git log --oneline
a3f9c12 init: the brief
7be21d0 research: who it is for
c41a9e3 feat(web): the builder web app
19d0f7a feat(mobile): review builds on the go
e8b3c55 feat(site): the website
5f2c8d1 refactor: key decisions
b72e4f0 fix: when it goes wrong
3c9d1a6 a11y: accessibility decisions
0aa7b94 style: design system
6e1f5b2 chore: what I left out of v1
d93e016 release: success targets, not results
f08a2c7 docs: reflection
$ ▍
role
Lead product designer, solo
timeline
6 weeks, planned
ships
Web app, mobile app, website
benchmarks
Lovable, v0, GitHub PRs
$ git log --graph main
commit a3f9c12·mohamed·week 1init

The brief

Draftboard is a concept: an AI builder that turns a prompt into a working internal tool. I wrote the brief as if from a client (the client is fictional). The problem: people love the first result, then lose trust when a follow-up prompt quietly rewrites screens they were happy with.

The goal: keep the speed of AI generation, but give people the control they get from code review, without asking them to read code.

Assumptions I designed against (not measured)

assumption
Follow-up prompts break things people already liked.
Validate by counting how often an accepted screen changes when the user asked for something else.
assumption
People spend longer repairing AI output than prompting.
Validate with time on task: prompting versus fixing, in moderated sessions.
assumption
Today’s builders explain changes to developers, not to the person who asked.
Based on a walkthrough of public builder demos, not interviews.

What I owned

  • Framing the problem and the assumptions above
  • Information architecture and flows for the builder, mobile app and website
  • All UI, the design system and the motion
  • The working prototypes on this page, built in HTML and JavaScript

Honest constraints

  • Solo concept project with a fictional client, so no real users, PM or engineers. In a real team I would check feasibility with engineering at each decision below.
  • No AI model behind the demo. Results follow a script, so I designed the states around the model, not its quality.
  • The main users are not developers, so code cannot be the main way to build trust.
  • Credits cost real money, so cost has to be visible before anyone spends it.

Planned timeline for this concept

About 6 weeks, split into five phases. This is how I would plan the work as a real engagement, not a record of time spent.

  1. Week 1
    Discover
    The brief, the assumptions and two proto-personas
  2. Week 2
    Design
    Builder layout and the change review flow
  3. Weeks 3 to 4
    Prototype
    Working builder, mobile review app and website
  4. Week 5
    Build
    Design system, failure states and accessibility pass
  5. Week 6
    Test and launch
    Test whether people read a change before accepting it, then set targets
commit 7be21d0·mohamed·week 1research

Who it is for

Two proto-personas, built from desk research and a walkthrough of public builder demos. They anchor decisions; they are not interview findings.

AO
Amara Osei
ops lead · builds tools without code
Persona voice

“I can describe the tool. I just can’t risk it breaking on Monday.”

  • Build internal tools without tickets
  • Change one thing without losing the rest
  • Know exactly what will go live
PR
Priya Rao
founder · reviews from her phone
Persona voice

“I start builds at my desk and check them in the queue at lunch.”

  • Follow long builds on the go
  • Approve small changes fast
  • Keep an eye on credits
research plan, not run

8 to 12 moderated sessions with people who do not write code. Task: change one screen of a working tool without breaking another. Pass if no participant loses work they had accepted.

riskiest assumption

People will read a change before accepting it. Cheapest test: 5 unmoderated sessions, tracking whether people open the preview or the summary before they click Accept.

commit c41a9e3·mohamed·week 2feat(web)

The builder web app

The builder in three panes: chat on the left, the live app in the middle, and changes, code and checks on the right. It opens with v2 live and v3 waiting for your review. Try it below.

app.draftboard.dev/refund-desk
draftboard /refund-desk main
History
444 credits
you
Build a refund approval tool for our support team
draftboard
Before I start: who should be able to approve refunds?
you
Only the support team
draftboard
Built Refund desk: a table of open refund requests with approve and reject actions. Accepted as v1.
you
Add filters by refund reason
draftboard
Added reason filters above the table. Counts update as refunds are decided. Accepted as v2.
you
Make approve buttons green and add bulk approve
draftboard
Changes are ready. Review them on the right.
  1. Update button variant
  2. Add row selection
  3. Add bulk approve with a confirm step
Enter to send · est. 12 credits, half back if you reject
Previewproposed v3refund-desk.draftboard.app
RRefund desk6 pending · €386
new
CustomerOrderReasonAmountStatusAction
Ava Thompson#40211Damaged€84Pending
Noah Brooks#40217Late€32Pending
Mia Rivera#40223Wrong item€119Pending
Liam Carter#40230Damaged€56Pending
Zoe Bennett#40238Late€24Pending
Ethan Price#40242Wrong item€71Pending
2 files changed+5 −1
components/Row.tsx
Approve turns green and every row gets a checkbox.2 lines added, 1 removed
components/BulkBar.tsx
Adds “Approve selected” so leads can clear several refunds at once.3 lines added
  • › Read each change in plain words in Changes. Show code reveals the diff
  • › Reject the Row.tsx change only, and see the warning that BulkBar needs it
  • › Accept v3, then hit Publish: one check fails on purpose. Fix it or roll back
  • › Scrub History to move between versions
Open full screen ↗
commit 19d0f7a·mohamed·week 3feat(mobile)

Review builds on the go

draftboard480 credits
0%
Building
refund-desk · v4
“Show the refund total at the top”
$ draftboard build refund-desk
Projects

Builds take minutes. Founders start one at their desk and want to check it from the queue at lunch. The mobile app is for watching, reviewing and nudging, not building.

Approving on a phone is fast, so it needed a safety net: every decision gets 5 seconds to undo, and approvals ship to the preview, never straight to the live app.

  • › Watch Builds stream in live, with the progress ring
  • › Approve or send back changes in Review, then try Undo
  • › Tap the mic in Prompt, speak a change and send it
  • › Check credits before you spend them
commit 5f2c8d1·mohamed·week 4refactor

Key decisions

- regenerate the whole app on every prompt
+ propose small changes, the user merges them
People trust changes they can read. Small changes also make rejected ideas easy to remember, so the AI stops repeating them.
rejected alternative
Regenerate, then highlight what moved. It is easier to build, but people still lose the parts they liked; they just see it happen.
- show code diffs to everyone
+ lead with what changes for users, code one click away
Amara reviews outcomes, not syntax. Each change opens with one plain line (“Approve turns green and every row gets a checkbox”); the code is behind Show code for whoever wants it.
rejected alternative
A separate simple mode and developer mode. It splits the product and hides the code from the people most likely to spot a problem.
- a chat log as the only history
+ versions you can scrub like a timeline
Rolling back should feel as safe as Ctrl Z. Restoring v1 after v3 is live keeps v2 and v3 in history: nothing is deleted. The main badge marks the one line of versions v1 supports.
rejected alternative
Branches in the interface. It is the right model for developers, but too much to learn in a first version for people who do not use git.
- “Publishing…” spinner
+ named checks that pass one by one, and stop if one fails
Showing the checks explains the wait and builds confidence before an app reaches a team.
rejected alternative
Run checks silently and only show failures. Faster to read, but people cannot tell a slow publish from a stuck one.
- plans picked from a table, a flat cost per prompt
+ a slider in “apps you change”, an estimate before each prompt, half price for rejected changes
People think in apps, not tokens. Charging full price for code you throw away would punish exactly the reviewing we want people to do.
rejected alternative
Unlimited prompts on a flat plan. Simple to sell, but heavy users would make it unaffordable to run and the price would have to jump later.
- a mobile clone of the builder
+ a review-only app, with Undo on every decision
On a phone people watch and decide. Approvals go to the preview, never straight to the live app, and Undo stays for 5 seconds. A one-flick deploy was the trade-off I refused.
rejected alternative
Hold to approve on every card. Safer, but slow for a stack of small changes, and harder for people with limited dexterity.
commit b72e4f0·mohamed·week 5fix

When it goes wrong

A demo where every check passes hides the real design problem. So the prototype breaks on purpose: accept v3 and publish, and the test for bulk approve fails because the AI dropped the confirm step it promised.

1 · a check fails
✓ Building · 2.1s
✕ Running 16 tests · 1 failing
· Security and access checks
· Deploying

“Approve selected skips the confirm step that v3 promised. Nothing went live: your team still sees v2.”

2 · two ways out
Ask AI to fix · ~4 creditsRoll back to v2

The fix arrives as a new change you can read, with its cost shown first. It is never a silent patch.

3 · recovered
✓ Running 17 tests · pass
✓ Deploying · 0.8s

“Fixed: Approve selected now asks ‘Approve 3 refunds?’ before it runs.” Or, after a rollback: v2 stays live and the v3 request waits in the chat.

Other ways it goes wrong, and what the UI does

  • A change that needs another. Reject Row.tsx but keep BulkBar.tsx and the builder stops you: “Approve selected uses the row checkboxes from Row.tsx. Accept both or neither.”
  • The AI misreads the prompt. The plan appears step by step before any code, and the first build asks one clarifying question (“Who should be able to approve refunds?”) instead of guessing.
  • You change your mind. Reject all returns half the credits and rolls the preview back to the live version.

Rules I set for failure

  • Nothing reaches the team until every check passes.
  • Every failure says what broke in plain words, then offers a fix and a way back.
  • A fix is a new change you review, with its cost shown before you spend.
commit 3c9d1a6·mohamed·week 5a11y

Accessibility decisions

  • Real buttons, real labels. Accept and reject are buttons named “Accept change” and “Reject change” with a pressed state, so review works with a keyboard and a screen reader.
  • Colour is never the only signal. Added and removed lines keep their + and − markers, and a rejected change is struck through and labelled “will not ship”.
  • No gesture-only actions. The mobile app decides with large tap buttons, and every decision can be undone for 5 seconds.
  • Visible focus. Every control shows a lime focus ring, including the prompt box, where the ring wraps the whole field.
  • Contrast on dark. Muted grey #8A919C is used only on the near-black panels, where it measures 5.2:1 or better; body copy is lighter still.
  • Announced status. Toasts use role=status and failures use role=alert, so a screen reader hears “A check failed” without hunting for it.
commit 0aa7b94·mohamed·week 5style

Design system

A dark dev-tool look: near-black panels, one lime accent for actions, and diff colours that mean the same thing everywhere. Space Grotesk for UI, JetBrains Mono for anything a machine wrote.

--bg
#0A0B0D
--panel
#111317
--line
#22262D
--text
#E6E8EB
--lime
#D7FF3B
--cyan
#3BE8FF
--add
#3DFFA2
--remove
#FF5C7A
Aa
Space Grotesk · interface
{ }
JetBrains Mono · code, logs, diffs
commit 6e1f5b2·mohamed·week 6chore

What I left out of v1

Scope is a design decision too. These were cut on purpose so the first version stays easy to understand.

  • Branches and several editors at once. One line of versions per app keeps v1 simple.
  • Building on a phone. The mobile app reviews and prompts; building stays on the desktop.
  • Auto-accepting small changes. Everything waits for a person in v1. Letting trusted, low-risk changes through automatically comes later, and only with a clear way to turn it off.
  • Comments on individual changes and live co-editing.
  • Choosing your own AI model and per-model pricing.
commit d93e016·mohamed·week 6release

Success targets, not results

Concept project: these are the targets I would test against, not results. No pilot was run.

metrictargethow it would be measured
Time to a first working appTarget: Under 60 s, medianFirst prompt to first preview, from product events
Changes accepted after reviewTarget: 80% or moreAccepted changes divided by proposed changes
Rollbacks after publishTarget: Under 5% of publishesRestores within 24 hours of a publish
Credits per kept changeTarget: Going down month on monthCredits spent divided by accepted changes
Accepted work lostTarget: 0 in validation sessionsParticipants who lose a change they accepted
commit f08a2c7·mohamed·week 6docs

Reflection

  • What I would change. I started with code diffs as the trust device and only later made the plain-language line the main layer. Next time I would start from the person who does not read code and add code for those who do.
  • The hardest part. Designing failure with no model behind the demo. Scripting one honest failure taught me more about the product than the whole happy path.
  • What I would test first. Whether people actually read a change before accepting it. If they do not, the review step is theatre and the product needs a different checkpoint, such as a required preview for changes to live apps.
Next project
Relay

AI agents for ops teams, with approvals and replays.

View case study →