Megan Casebier

Case study · Obie, 2026 · 11 min read

It looks like a prototype. It’s built like a product.

Everyone is trying to make AI delivery fast. Fast is free now. The expensive part is making it safe, legible and adoptable, then proving it by handing the work to an engineer who wasn’t in the room.

Timeline
May – Oct 2026
Team
Three PMs, a UI designer, engineering
Surfaces
A core account page · Underwriting workbench

Safe enough to point at a regulated insurance product. Legible enough that nobody wonders what the machine did. Adoptable enough that someone else can pick it up.

The system behind design’s working prototype of a core account page isn’t about prompts. It’s an operating system: a public queue for design work, a written record of every decision, and a rulebook that governs AI sessions when I’m not watching. Three moves: derive the truth, govern the risk, and design for whoever inherits it.

  • 6 days, mandate to a hosted working prototype
  • ~5 hours, stakeholder feedback to the hosted prototype

Obie’s production product is built by engineering, in its own stack. The prototype is the reference, not the code that ships.

The first two tools had nothing to do with AI.

Design work arrived from three PMs as DMs and drive-bys, with “ASAP” doing the job of a date. The scarcity was never the problem. The invisibility of the scarcity was.

The Line was one public, ordered queue for all design work. The alternative was the private to-do list every designer keeps, which makes the designer the bottleneck. The public version costs something too: every slot is visible, so every slot is open to negotiation.

The Line: a page titled Design, The Line, with its house rules on top, then six ordered rows of design work, each showing the PM's need-by date beside design's target date and a status. A note below the table says intake below the line has no date until it enters the line.
The Line, recreated for this page. The structure and house rules are as shipped; the rows are representative of one week in August, with internal project names made generic.

The VP endorsed it in writing the morning I pitched it. “ASAP is not a date” was policy by lunch. About a week later, a PM asked to swap her project’s slot with another’s. She was negotiating with the queue, not with me.

The decision log did the same for arguments: nine dated decisions for a new underwriting tool, each with its options, resolution and consequences, and the unresolved risks labeled “pending technical verification” so they’d surface as line items instead of surprises. Reopening a decision meant arguing with a dated document, not a memory.

By August, design had a record nobody could reopen and a schedule nobody could jump. Then the VP asked for an application.

The first commit was a rulebook.

In early August, the VP challenged design to stand up a working application without engineering. The tools existed. A reason to trust them didn’t. The risk was never the code. It was everything around it: what data may exist in the repository, how changes reach main, and what the machine does with a question it can’t answer. Get those wrong and you have confident fiction pointed at a regulated insurance product.

The usual order is to build first and govern once something works. I reversed it. My first commit was a conventions document, and everything after it inherited the rules:

  • All data is fictional. Not anonymized, not sampled.
  • Production code is read-only.
  • Every change goes branch, pull request, merge, with tests green. No shortcuts for speed.
  • Visual values come from the design file’s API, never eyeballed.
  • When an agent hits ambiguity, it asks instead of guessing. This is the rule that makes the rest work.

The price was paid up front and again on every change after: the application waited behind its rules, and no change skipped the pipeline to go faster. Made generic, the rulebook is the Foreman Method.

The first commit of the account-page prototype repository, dated August 6, 2026 at 1:50 PM, showing the opening lines of its conventions document: the prototype runs on fixtures, with no backend, no database, no auth and no real client data, and all data passes through one access seam. A footer shows the first application-code commit landed 33 minutes later.
Commit one, recreated from the repository’s git history, with people and internal repositories replaced by roles. The first line of application code landed 33 minutes later.

Six days after the challenge, there was a hosted working application. About ten days in, an unattended overnight session ran a secret scan before pushing and flagged a mismatch between its instructions and the deployment plan instead of quietly fixing it. A well-written process document scales in a way attention never will.

Terminal output of megancasebier.com’s own publish gate refusing a staged breakage
The same kind of gate runs this website. Here it refuses a staged breakage.

One brief, five builds.

By mid-August the bottleneck was me. One agent session per pull request meant every brief waited for me to shepherd the last one.

So on a Saturday morning, with five pull requests’ worth of settled decisions, I split one master brief into five build plans, handed each to its own governed session, and took my dog for a 45-minute walk. Five draft pull requests were waiting when we got home. The feature set was due Monday. It was live that Saturday, two days early.

Percy, a black husky mix with pale blue eyes, on a leash on a leaf-covered path under autumn trees
Percy, three-year-old husky mix and requirer of at least one three-mile walk a day. Hence the robot army.
Five merged pull requests, numbered 46 through 50, each titled with the name of the build session that produced it: documents-cleanup, activity-log-restyle, status-chips, billing-autopay-variant and overview-polish. All five merged on Saturday August 22, 2026, between 9:52 and 9:56 AM.
That Saturday’s five pull requests, recreated from the repository’s history with authors and reviewers removed. Each title starts with its session’s name.

Each build gets its own isolated copy of the codebase, a name that follows it into its pull request, and the standing rules, with authorities ranked: written decisions beat mocks, and ambiguity comes back as a numbered question, never a guess.

The bet was parallel builds over one shepherded session, and the cost lands on me: five builds, five sets of questions. Does this render if the design doesn’t show it? Who sees this tab? I answer them in batches, in writing, and every answer becomes a rule later sessions inherit. Most process makes ambiguity recur. This one makes it cheaper over time.

The job had changed. It wasn’t typing, or even directing. It was specifying, ruling and reviewing.

Truth flows one way.

Sprints make good stories. Systems make good products. This one starts with truth flowing one way.

  1. Decisionmade in a working session, written down
  2. Mockupdated in the design file
  3. Codevalues extracted through the design file’s API

Drift doesn’t get fixed silently. It comes back as a question: the mock says X, the code says Y. Which is right?

One direction. Skipping the mock isn’t a shortcut; it’s a broken pipe.

The alternative is parity by care: someone holds a screenshot against the build and trusts their eyes. I made parity a machine check, and the cost is that nothing drifts quietly. Rename a label and the build fails until the code agrees.

The status word that check caught is the diff’s story. The list of states doesn’t claim to be complete, either; it proves it, walking every fictional policy through every term and role.

It still moves fast. Late in August, an agency-facing stakeholder pushed to move additional parties off the overview and into their own tab. He was right, and it was live about five hours later, with the fictional cast recalibrated to the ratios a read-only pass over production code found, and two hundred new tests. The request came out more truthful than it went in.

Where the hard decision landed.

The prototype became the plan of record. What that moved shows best against the last project that ran the old way, the 2025 quote builder.

Where the hard decision landed, in weeks from design start Quote builder, 2025: design starts Jul 22, build starts Oct 13, and the core interaction is re-decided after the build began; it ships Feb 17. A core account page, 2026: starts Aug 6; structure, banners and billing are decided inside the prototype in the first weeks, before any spec; sign-off is requested Sep 9; the final design is built by Oct 15. 2025 Quote builder Jul 22 · design starts Feb 17 · ships Oct 13 · build starts Core interaction re-decided — after the build began component struck · tickets re-cut 2026 Account page Aug 6 · start Sep 9 · sign-off requested Oct 15 · final design built Structure, banners, billing decided inside the prototype — before any spec Weeks 048121620242832
Where the hard decision landed. Weeks are approximate. Sources: Jira, Confluence, Slack, git

Nobody did anything wrong. The process asked its hardest questions last, after the cheapest moment to answer them had passed.

The workflow that replaced it has five stages. Each has an owner, and each hands the next something it can click, not something it has to interpret.

StageOwnerGate
The PM makes the requirement clickable. In whatever the PM thinks in — Figma Make, Cursor.PMStakeholders have clicked it, not read about it.
We decide inside it. Product and design settle disagreements by clicking through the options instead of describing them.PM + designEach decision is written down, once.
Figma becomes the source of truth. The UI designer and I turn the agreed direction into the system.Design + UIThe prototype never runs ahead of Figma for long — a rule we adopted the week it did.
I build working software on production shapes. Fictional data in the platform’s real wire format, every documented state reachable, tests as the contract.DesignNothing merges without the tests.
Engineering builds from it. Engineering owns architecture, security and the production stack.EngineeringTheir spec, their review.

Stage five is built around engineering’s own position, not against it. Engineering had already set its terms for AI prototypes: useful as requirements, not production software. I agreed, and designed the handoff to respect it.

The method ran three times.

StageAgency onboardingCore account pageUnderwriting workbench
Made clickablePMs’ working app (Cursor)PM’s structure spec → my first working versionPM’s Figma Make file
Decided inside itWith the agency teamWith product, underwriting and servicingWith underwriting stakeholders
Source of truthUI designer’s FigmaFigma, with a written protocolUI designer’s Figma
Working softwareMy redesign; six of my commits merged in the production repoThe prototype (above)A display layer built to the production team’s conventions
EngineeringRebuilt and hardenedThe prototype is the referenceAdoption manifest delivered
StatusLive · Aug 5Prototype deliveredHanded off; an engineering pod is building from it

Agency onboarding ran before any of the rules existed, and it’s where design first contributed code to a production repository: six small UI commits, reviewed and merged by engineering. The core account page ran with the rules in place; tab structure, banner behavior and where billing lives were settled in the prototype before a spec existed, and sign-off was requested on September 9.

Run once, it’s a project. Run three times, by different PMs, it’s how the team works.

Engineering inherited it.

The prototype settles what the page does: its structure, its vocabulary and its display rules, down to example amounts drawn from fictional policies. Engineering owns how it runs.

The workbench went further toward shared code, and that was the last bet. The safe version was the one stage five describes: hand over a working app as reference and let engineering rebuild it. Instead, under an adoption agreement, design authors the display components in the production team’s conventions, and their pod owns the data wiring and the review. The cost is building to someone else’s conventions, and to their stack as it stood.

A good handoff isn’t a file engineering accepts. It’s a decision engineering doesn’t have to make again.

An engineer picked it up cold.

A delivery system that works through its author’s hands proves authorship. That doesn’t prove the documentation is complete enough for anyone else.

The workbench was the test: a rules-engine interface, dense and operational. The engineer who owns the adoption pipeline asked, in writing, for the prototype to be built from reusable components, every leaf and branch defined for the engineers who would build it. Engineering didn’t tolerate design-authored code on this project. It specified requirements for it.

The first leaf, a status-badge set, went live in a browsable gallery on Aug 28, 2026. Then the delivery interface itself got co-designed with its consumer: an extraction manifest per component, listing exact files, dependencies and pinned versions. Before scaling past the first one, I asked the owning engineer whether this was the shape engineering wanted, while changing it was still cheap.

The extraction manifest: what to copy, what it needs, and which build it was checked against. A recreation with invented names.

Then the stack changed.

Mid-project, the production build moved to a different component library than the prototype assumed. Part of what I had built to the old assumption was now worth less. This is where delivery systems usually start lying: send everything as if nothing moved, and let the engineer find the soft spots himself.

The written law says outbound documents get re-verified at send time. So the handoff went out with the degradation flagged by me, unprompted: this part is from when we thought it’d be a different stack; it’s significantly less helpful now.

That was the bill, paid in my own words. A handoff that advertises its own weak spots is the only kind an engineer learns to trust.

Tuesday.

Tuesday morning, an implementation engineer I’d barely worked with, not the pipeline’s owner and not someone who’d watched the system evolve, asked for the design materials for his build ticket. The entire handoff was one message: the repo, the live prototype, the design source of truth. I asked for one thing back: an honest read on what was useful and what wasn’t.

Wednesday, 9:35am, about a day later, he posted a live review build of the dashboard. In writing, the implementation engineer said that between the handoff and the Figma file, he had matched the design almost exactly.

On the other library. From one message.

The dashboard as designed, recreated with invented rules and carriers. His build follows.
The engineer’s build of the rules list: rule groups with carrier chips, line of business, version, author, effective date and change description. Re-staged with fictional data.
His build of the same list, on the other component library. Same design, different machinery. The real interface, re-staged with fictional data.
The engineer’s build of a rule group’s Graph tab: a request node, the rules table node with Edit Table and Settings, and a response node. Re-staged with fictional data.
Inside the same build: a rule group’s graph, where the table sits between request and response. Re-staged with fictional data.

Context beat code.

The honest read came back as a ranking of delivery approaches, and the winner wasn’t the full working prototype. It was the context-rich design artifact built alongside AI: enough embedded intent and structure for engineering to pull into their own harnesses and adapt, without adopting someone else’s app wholesale.

That trimmed my favorite artifact. The full prototype keeps its job, where stakeholders experience the truth of a design before anyone commits. For the transfer itself, context beat code. The finding got recorded, not defended.

The system’s output was never really code. It was context complete enough that the next person could build correctly without me in the room.

It stopped being mine.

All three of our PMs now prototype their own requirements. One of them pioneered it before I’d used the tool; when I needed to move work from Figma Make into Figma, I asked her how. In October, a PM, two engineers and I presented the approach to the whole product and engineering department as Breaking the Handoff.

What I builtWhat others built
The path between the stages, and the rules that hold it togetherThe first Figma Make experiments, by a PM
The Line, one public queue for all design work (above)Every product decision; the PMs ruled
Working prototypes on production data shapesFinal UI, by the UI designer
The adoption agreements with engineeringProduction code, by engineering

I didn’t introduce the tool. I built the road between the people already using it.

What it changed, and what isn’t measured yet

A comparable project under the old process spent roughly a quarter in design churn before its interface reached QA. The account page absorbed a similar load of contested decisions in roughly a month.

  • Rework in production. Not measured yet.
  • The real scoreboard. Before the redesign, agents wrote in every week about billing, cancellations and renewals. How often they still have to is the test.
  • Workbench code reuse. Agreed and delivered to the first handoff; not yet merged in production.

The prototypes got fast. The scoreboard is next.

The handoff-to-review-build window is verified by message timestamps, Oct 27–28, 2026. The engineer’s words are reported with his consent and attributed by role. The rulebook is the Method page; the component inventory that started the adoption thread is the diff that audited the design system; the same project through the design lens is When the core can’t change, design owns the path and the record.

Building something in this lane? Email me.