Designing an AI stylist people let into their closet

Where I started

I joined OWNE when it was a founding belief and a few marketplace screens. The belief: resale is broken because people don't know what they own, what it's worth, or whether it's real. An AI stylist who knows your closet could fix all three.

The obvious brief was "design the stylist". The first thing I did was argue that the stylist was the easy part. The hard part was the data she needs. Nobody hands a stranger their wardrobe on day one.

Discovery: three questions

I ran discovery around three questions, because the answers would decide the architecture:

1. What does it take for someone to photograph their own closet? The cold-start problem.
2. When does an AI suggestion feel like help, and when does it feel like a stranger touching your clothes? The trust problem.
3. What would make someone believe an authentication result? The stakes problem.

Owners first. I talked to people who own and resell luxury pieces, reached through the founders' network. I asked each of them to open their camera roll and show me the last piece they'd bought, then the last one they'd sold. The camera roll turned out to be the real onboarding surface: most already had photos of what they owned, badly lit and uncatalogued. That is where Nia's first interaction now starts.

The model second. Before drawing anything, I spent two weeks with the AI lead looking at real outputs from the recognition and styling models: what they got right from a single photo (category, colour), what they guessed (brand, model), and where they were confidently wrong (authenticity from one image). I kept every miss in a running failure gallery in Figma. That gallery decided where the interface had to let the user correct the model, and it stayed open for the whole project.

The market third. A teardown across three categories nobody had combined: resale marketplaces, closet apps and AI stylists. Each solved a third of the problem and asked for the whole wardrobe to do it.

What came out of it

Three findings that became the product's rules:

• People will do tedious work if they see value accumulate as they go. They will not do it on a promise. → the closet valuation meter
• People argue with suggestions. The ones they can't argue with, they ignore. → show reasoning, not confidence
• A result is believed in proportion to the rigour people watched go into it. → design the input to protect the output

How I worked: prototypes in code, not pictures

Figma can't show you an agent. A static frame of a chat says nothing about what happens when the model is slow, wrong, or confident about the wrong bag. So from the first week I built the AI surfaces as working prototypes with Claude Code: React screens wired to the real model endpoints where engineering had them, and to scripted responses drawn from the failure gallery where they didn't.

That changed three things:

• Reviews were about behaviour. Founders and the AI lead reacted to Nia misidentifying a bag in a live prototype, not to a mockup where she was always right.
• The prompt became a design material. I wrote and iterated Nia's response structure alongside the UI. Every recommendation must return one reason per register (functional, aesthetic, personal) or it doesn't render. The interface constraint shaped the prompt, not the other way round.
• Handoff was specs plus code. For each AI surface, engineering got the prototype, plus a behaviour spec: what Nia does on success, on low confidence, on no data, and on user correction.

Three rules for the agent

These came out of discovery, and I held every screen to them in review.

Rule 1 — Nia proposes. She never acts.

Nia's first real interaction is also the highest-stakes one: she scans the camera roll and offers to build the closet from what she finds.

Version A, the obvious one. Import everything, show "42 items added", let the user fix it later. Fast to build, and hid the model's error rate.

Version B, review everything first. One long confirmation list before anything is added. Safe, and in the prototype people stalled on it: forty decisions before any value.

Version C, shipped. Each detected item arrives as its own card with Edit and Add item. The message ends with "You can also add some items manually" and a Not now.

C is slower than A, and it's the reason people finish. When the model is wrong about a bag, and it is often enough, the cost is one tap, not the user's confidence in everything Nia says afterwards. This became a product-wide contract: every AI output in OWNE is a reviewable object, never a completed action.

Rule 2 — Show reasoning, not confidence.

Nia reads the day, not just the closet: calendar, weather, location. A recommendation is only useful if you can argue with it, so each one carries its reasons in plain language rather than a score. Three registers, on purpose: one functional ("rain until four"), one aesthetic ("the camel coat balances the black boots"), one personal ("you haven't worn this since March").

People disagree with different registers, and each disagreement is a legible signal back to the model. I prototyped a confidence percentage first. Nobody knew what to do with it; a number gives you nothing to push against. It went.

Rule 3 — Design the input to protect the output.

Authentication is the highest-stakes model output in the product: a €13,000 bag either is or isn't real. Rather than presenting a probability at the end, I spent the design effort at the front: a stepped capture flow that asks for the whole bag, then the zipper, then the logo, then the serial, with framing guides, lighting warnings and a retake gate before every upload.

The model gets better inputs. The user gets a process they can watch working. Certainty in a result is earned by visible rigour before it, not asserted after it.

Testing with ten owners

Before beta, ten people outside the team used the working prototype on their own phones with their own camera rolls, which was the point: a scripted demo closet would have hidden exactly the failures we needed to see.

What changed as a result

• The Not now on closet import was added after watching people feel trapped by a flow that only offered Edit or Add.
• The lighting warning in authentication capture moved from after the upload to before it, once we saw how many photos were retaken.
• Reasons replaced the confidence score on Nia's suggestions (Rule 2) after testers skipped past the percentage without reading it.

What didn't change despite feedback: several testers wanted Nia to "just add everything". We kept the per-item review. The cost of one wrong bag in a valued closet is higher than the cost of forty taps, and the design has to protect the user from the model's bad day, not only serve the good one.

Reflection

A tension I'd still test

Nia has a human face and a human name (she was Léa first). Warmth converts; it also overclaims. The counterweight in the shipped design is the strip under every exchange, AI powered · Personalised · Always by your side, which never lets the interface pretend she's a person. I think that's the right trade at this stage. I'd want a study to say so.

What I'd do differently

Define the three metrics above with engineering before beta, so the data exists from day one rather than being retrofitted. And build the code prototype from week one, not week three: the two weeks I spent in Figma on the agent surfaces produced nothing that survived contact with the real model.

What comes next: voice

The composer already carries a voice affordance, and styling is one of the rare assistant tasks that is hands-busy: you are standing in front of a mirror holding clothes. The interaction I'd design next is Nia spoken, under the same three rules. She proposes, she gives her reasons, she never acts alone.