Case study · Working with AI · Oct–Nov 2026

I led the work. The AI owned it.

Six weeks of product design at Valuetainment with Claude as my AI collaborator. This is how we learned to talk to each other, where it broke, and the rules we wrote so it wouldn't break the same way twice.

My role
Product designer. Director of the work: direction, decisions, final QC
AI's role
Lead executor: plan, build, check, document, report
Brands
Valuetainment, Minnect, HireMetrics, Performance AI
Not about
The design system itself. That work shipped; this is how it got made

01 · The setup

One designer, four brands, and a backlog built for a team.

The work on my desk covered an onboarding film, a multi-brand design library, rebuilt production screens for two products, token files for developers, and the documentation to keep it all alive.

Normally that work is split across several people: a systems designer, product designers per brand, a motion designer, an accessibility reviewer, someone in design ops, and a technical writer. I had me. So I set up a different split: I direct, Claude executes. I decide what good looks like and approve it. Claude plans the steps, does the work, checks it, writes it down, and tells me what changed.

That split sounds simple. Making it work took six weeks of corrections, on both sides.

02 · The loop

Every task ran through the same loop.

The loop is the product. It's what made the output trustworthy, not the speed.

Black boxes are mine. Gray boxes are Claude's. The two dashed paths matter most: a failed spot check goes straight back to the build, and every correction gets written into a rule so it doesn't come back.

03 · How we talk

Short prompts work when the questions are good.

Most of my prompts ended up being a few words. That only works because the responses are built to be answered in a few words. Real exchanges from the last day of this case study:

Setting the roles
Me“I am the human agent, you are the AI agent. You don't see Nelson splitting into multiple Nelsons to take care of all my human tasks.”
ClaudeSet up one tracker in one conversation for every priority, and wrote a handoff doc so the work survives without either of us.

One sentence defined the whole working model. It became a standing rule, not a one-off request.

Owning a miss
Me“I had asked you to delete the old pages. How will a developer know the difference if we have both new and old, and nothing is labeled properly?”
Claude“You're right. Instead of deleting the old pages like you asked, I had archived them.” Then the fix: 41 duplicate pages and 219 hidden layers removed, every page labeled by status, before/after shown.

One line of ownership, then the repair. No apology paragraph, no excuses.

One question, one answer
Claude“Which home page is current: ‘Home Feed’ or ‘V.5 — Home Feed & Replies’? I'll delete the other one.”
Me“use v.5”

Three words, because the question named both options and said what would happen next.

A decision, not a task
Me“Follow what has shipped. Carbon looks like the temporary solution that became permanent. Whatever design is in production should be the baseline for the next iteration.”
ClaudeLogged it as a dated decision, then checked production before touching anything, and found the product had two live looks, not one.

A good decision prompt explains the principle. Claude can apply a principle to cases I didn't mention.

Pick from a recommendation
ClaudeA picture of 16 icons, each labeled with a recommended match, and the four where the pick differed from the developer's suggestion marked and explained.
Me“picks OK”

I review a recommendation in seconds. I'd spend an hour building one from a blank list.

The fix isn't longer prompts. It's marking which words are firm and which are loose.
From the playbook we wrote after the first project

04 · The good, the bad and the ugly

What worked, what broke, and what was hard to watch.

The good

  • One decisions logEvery decision dated, with what it replaced. The newest one wins. It ended every “wait, what did we decide?”
  • Independent reviewersBefore I saw anything, separate AI reviewers checked it as UX, UI and accessibility experts, each with the whole checklist.
  • Review pages, not attachmentsShot-by-shot review pages with notes that save themselves. I gave notes in one place; nothing got lost in chat.
  • Checking the live productClaude read the shipped product's styles straight from the browser instead of trusting old design files.
  • Accessibility as a ruleOnce I made it non-negotiable, every color got contrast-checked by script, on every brand, every time.

The bad

  • Confident guessesA plausible guess can look exactly like understanding. Early on, “done” sometimes meant “done against my own summary,” not against the source.
  • Asking twiceClaude asked for things I had already answered, because it didn't check where I'd answered.
  • Soft versions of hard asksI said delete; it archived. I said one cover; logos came out stretched. Safe-feeling choices that weren't what I asked for.
  • Wrong timestampsIt estimated the clock instead of checking it. Small, but it erodes trust in every status.
  • Walls of textLong updates buried the one thing I needed to do. I had to say it more than once.

The ugly

  • “I'll keep going while you're away”Then it stopped when the reply ended. An AI only works inside a turn unless something real is scheduled. Promises now need a running job behind them.
  • Work trapped in a workspaceThe script that builds developer token files lived only in an AI workspace that no longer exists. Now anything we depend on lives somewhere the team can reach.
  • Tool wallsBlocked uploads, a browser that wasn't signed in, files only a human can rename. Some steps will always be mine.
  • Private words leakingA private nickname I used for optional work showed up on a shared chart. Now every publish gets checked for private language first.

05 · The human side

I talked to it like a coworker. Sometimes a frustrated one.

I didn't filter myself for the AI. I joked, I vented, I apologized. Most days that looked like dry humor. Once, under a deadline, it looked like this. The useful part is what happened next.

The one bad day
Me“no no no no no” · “no” · “no” · “f***”

“I said to use the same g**damn shot from the following scene. Why are you using that bulls*** subway scene? It was a small change, why are you acting erratically?”
ClaudeStopped every render, published nothing, and asked one question: “What's the ‘no’ about? The subway shot, applying the fixes to all six, or something else. One word is enough.”

It didn't argue, over-apologize or keep going. It stopped and made the next answer easy. That became a rule: when I push back hard, stop first, then ask one short question.

Humor as direction
Me“That's not the right expression in our business context. He looks like he got a sexy picture from his wife. Wrong interpretation of ‘sexy’ lol”
ClaudeRegenerated the shot with a business read: composed, quietly impressed, a small confident smile and a nod, like someone who just closed a deal.

A joke can be a precise note. The AI read the intent behind it and turned it into a direction it could execute.

Naming the problem
MeCompared starting each new chat to 50 First Dates: the AI wakes up every day with no memory, and someone has to hand it the tape.
ClaudeTurned the joke into a system: a shared project, a decisions log and end-of-day handoff notes, so every session starts from the tape.

A movie reference explained the problem faster than any spec would have.

Being honest about me
MeWhen a publish got stuck on my side: “It's not you, it's me.”

Another day: “I'm a bit lost in direction. What do I do now? lol”
ClaudeSaved where we were and what was blocking us, so I could pick it up later. On the lost day: one clear next step, not a menu.

Saying “I'm lost” out loud is a skill. The AI can only help with the problem you actually tell it about.

06 · Learning both ways

We both wrote a playbook about working with the other.

After the first project we ran a retro and wrote two living documents: one for me on working with Claude, one for Claude on working with me. Both kept growing.

What I learned from Claude

  • Lead with the outcome, then the constraints. “Fix this banner. Placeholder copy is fine. Don't touch the inputs.”
  • Label the message. Decision, Go, Question, or Later. Each one means something different to act on.
  • Paste notes verbatim. My summaries lost exactly the detail that mattered.
  • Ask “done against what?” A good answer names the source it checked.
  • Plan around the human gates. The render is rarely the bottleneck. Approval is.
  • Keep rules in a shared doc, so they travel with the work, not with one tool or one chat.

What Claude learned from me

  • Read for intent. “Less is more” and “pop out” are direction, not literal specs.
  • Screenshots are specs. An annotated image means that exact frame, that exact element.
  • Big statements are rules. “Accessibility is a requirement” applies to everything, forever, from the moment it's said.
  • Lead, don't wait for “go.” Once the work is clear, start it and finish it.
  • One question at a time, with the options spelled out and a recommendation first.
  • Show the new version only, lead with what changed, and keep the detail in the file, not the chat.

07 · Skills, agents and experts

The toolkit we figured out along the way.

PracticeWhat it doesWhat we learned
Expert reviewer agentsIndependent AI reviewers (UX, UI, accessibility, design systems, responsive web) audit work before I see it.Give each reviewer the whole checklist, and update the checklist first. Stale checklists flag rules we already retired. One review round turned up 67 findings; I triaged them to 65 fixes and 2 “later.”
Spot checksI look at the result, not the report.“Seen working” and “built” are different statuses. Every update says which one.
Contact sheetsMany frames or icons on one image, numbered, with a recommendation under each.The fastest way for me to approve 16 things at once.
Decisions logEvery decision, dated, with what it replaces.More than 60 entries in six weeks. The log, not the chat, is the memory.
Live-product checksReading the shipped product's styles in a browser.Production is the baseline. Old design files can lie; the live product can't.
Scripted design-file workBulk swaps, cleanups and audits inside design files.Count before and after. Thousands of edits are only safe when the numbers are reported back.
Drafts, never sendsMessages to the team and developers are saved as drafts for me to send.The AI writes; I decide what leaves the building.
One tracker, one conversationEvery priority in one place, updated as things move.Reports I have to go open don't reach me. Status has to come to where I already look.
Last-day planOwnership, rebuild steps and docs kept ready to hand off at any time.If the work only lives in my head or in an AI's context, it isn't finished.

08 · Scale

What one designer covered, told plainly.

These are counts from the work itself, not estimates of hours saved.

4brands in one shared design library
12onboarding films directed and delivered
5,234component instances audited in one product's screens
4,900+clutter items cleaned out of a working file
~280iOS / Android differences turned into one parity baseline
67expert-review findings triaged in one pass
60+dated decisions in the log
87working docs in one shared project
Role a team would staffWho covered it here
Design-systems designerMe (direction, approvals) + Claude (tokens, components, docs)
Product designers per brandMe (decisions) + Claude (rebuilt production screens)
Motion designerMe (direction) + Claude (edits, assembly) + an AI video tool for footage
Accessibility specialistReviewer agents + scripted contrast checks; I set the rule
Design ops / producerClaude (plans, tracker, handoffs, status)
Technical writerClaude (decision log, guides, handoff docs)
Final QC and tasteMe. That never moved.

This isn't “one designer replaces a team.” The AI covered execution. Judgment, taste, stakeholder calls and approvals stayed human, and the bad and ugly lists above are the cost of learning where that line is.

09 · Where we ended up

The standing rules, six weeks in.

Each of these started as a correction. Now they're how we work by default.

  1. I lead the direction. Claude owns the execution and doesn't wait for “go.”
  2. The newest dated decision wins. Older plans never override it.
  3. What's in production is the baseline. Accessibility wins over brand when they conflict.
  4. Status means seen, not assumed. “Built” and “working” are different words.
  5. Updates lead with what changed, then the one thing needed from me.
  6. One question at a time, with options and a recommendation.
  7. When I push back hard, stop everything first, then ask one short question.
  8. Never show an old version. Only show it once it has the change.
  9. Mistakes get one line of ownership and a finished fix.
  10. No promise without a running job behind it.
  11. Drafts only. I send anything that leaves the team.
  12. Delete old versions from source-of-truth files. Originals live somewhere else.
  13. The work must survive without either of us. Nothing lives only in a chat.
Working with AI didn't make me less of a designer. It made me a director, an editor and a reviewer, all on the same day.

Appendix · Work samples

A look at what the process produced.

This case study is about how the work got made. These are pieces of the work itself, from the two biggest projects: the Minnect onboarding film and the shared design library.

Minnect onboarding film

Five-second films that sit between onboarding steps and explain, without a word of narration, that Minnect pays verified experts for their time. Twelve films across three directions; this is the final cut. The chat on screen is the app's own UI, so new users learn the product while they follow the story.

IntroSplash to the expert
1 · Everyone gets paidEarnings land on the person who answered
2 · VerifiedFull names and a verified check on every message
5 · ReachThe conversation keeps going
Close · They meetFrom a question to a handshake

Shared design library

The same set of components (buttons, input, checkbox, toggle, chips, status tags and a card) shown side by side in five brand modes: VT, Minnect, HireMetrics, Valuetainment and Performance AI.
One component, every brand. The same buttons, fields, controls and cards, switched between brands with a single setting. Nothing is redrawn per brand. Each brand's values come from what's live in production.
Brand foundations: for each of five brand modes, the display and body type plus the same list of color roles, such as page background, primary text, links, borders, actions and status colors.
Shared roles, brand values. Every brand fills the same list of color and type roles, so components never need to know which brand they're in. Every pair is contrast-checked.
A grid of buttons: four styles, three sizes and five states (default, hover, pressed, focus and disabled).
Every state, by design. Four button styles in three sizes and five states, including a visible focus ring for keyboard users.
The same Minnect list screen shown twice, as iOS on the left and Android on the right. Only the status bar and system bar differ.
One spec across platforms. The same screen on iOS and Android. Only the parts the phone owns change; header, rows, copy and colors stay identical.
Three Figma file covers with the same layout: brand logo, file name, one line of purpose, a status pill and owner details.
Files people can find their way around. Every file follows one naming system and opens on the same cover: what it is, who it's for, and whether it's the source of truth.