{/* 1 — HERO */}

{ e.preventDefault(); onNav('home'); }}>← Back to work

Dearly

Designing a commerce experience that starts from intent, not categories.

{['Product Strategy', 'Mobile App Design', 'AI-Assisted Design'].map((t, i) => {t})}

RoleSolo product designer (self-directed exploration, not a client or employer project)

Duration1 week, self-imposed, no external deadline

ToolsFigma, Claude Design, Pinterest, Mobbin, Dribbble, Behance

✦A note on how this project was built

This is a self-directed design exploration, not a commissioned product. I used Claude Design as part of the process, and I've kept that visible throughout rather than presenting the output as fully hand-crafted, including where I think the AI-assisted output falls short. I think that honesty is part of the point of sharing this project.

{/* 2 — OVERVIEW */}

Overview

A few months ago I noticed something small about how I was finding things day to day: I'd stopped searching. I wasn't browsing categories or filtering products down, I was opening an app already knowing the outcome I wanted, and describing that outcome directly.

The clearest example was buying a gift for my mum. I didn't search "gardening gifts under $50." I asked ChatGPT for gift ideas for my mum, who loves gardening, on a budget under fifty dollars. I did the same thing on Pinterest, then TikTok. Afterwards it struck me that I hadn't searched for a single product. I'd described an outcome and let something else figure out the rest.

That observation is what kicked this project off: Dearly, an exploration of what a commerce experience looks like when it starts from intent instead of categories and filters.

{/* 3 — TWO QUESTIONS, NOT ONE */}

Two questions, not one

I set this project up to answer two things at once, deliberately, not by accident.

The product question

Can a commerce experience actually work if it starts from intent rather than categories?

The process question

How far can I take a concept, from a vague personal observation to a decision-ready, high-fidelity prototype, if I treat AI tools as active collaborators rather than a shortcut at the end?

I'm genuinely curious about where these tools are useful, where they mislead, and what changes about design thinking when a prompt becomes part of the craft. This project was as much a test of that as it was a test of the commerce idea itself, and I've tried to keep both threads visible rather than tidying the AI parts into a footnote.

{/* 4 — VALIDATING THE SHIFT + PERSONAS */}

Validating the shift

Validating the shift before designing anything

Before I designed a single screen, I wanted to check whether this was a real, broader pattern, not just something specific to my own habits.

It is. Search and interface design has moved through a fairly well-documented arc: from blue links, to structured knowledge panels, to more contextual layouts, and now to systems that respond directly to what someone's trying to do. That's a behavioural shift that interfaces are still catching up to, not just an AI trend layered on top of old habits.

How might we design a commerce experience that starts from intent and returns results, instead of making people translate what they want into categories and filters first?

Two personas anchored the rest of the project

Together they point at the same underlying need from two directions: Ellie needs the system to act on clear intent immediately, Sam needs the system to help him find intent he hasn't fully articulated yet.

{/* 5 — FRAMING AS A PRODUCT */}

Framing this as a product

It's easy for a self-directed exploration to stay purely conceptual, so before moving into design, I forced myself to answer the questions I'd ask if this were a real product with real constraints.

The riskiest assumption

That a single clarifying question is enough to resolve ambiguous intent without the experience collapsing back into category browsing. If that assumption is wrong, the interface either guesses badly, poor recommendations, no trust, or asks so many questions it becomes the exact research-heavy experience Ellie and Sam are trying to avoid. This is the thing I'd want to test first and cheapest if I took this further, not the visual design.

What success would mean

Not just "it feels effortless." I'd want to track intent-to-selection conversion, the average number of clarifying questions before someone reaches a decision, and how satisfaction on AI-curated picks compares to satisfaction on self-browsed picks. Those numbers would tell me whether the core mechanic is actually working, not just whether the UI looks intentional.

What I'd cut with half the time

The chat-first direction wouldn't have been built out at all, it's the highest-effort, lowest-conviction option of the three. I'd have gone straight to the structured, intent-first direction, and spent the saved time testing the single clarifying question mechanic with real people instead of polishing visuals nobody had validated yet.

{/* 6 — EXPLORING THREE DIRECTIONS */}

Exploring three directions

Before building any of these out in high fidelity, I sketched all three as low-fidelity wireframes side by side, so I could compare the underlying structure of each idea before getting distracted by visual polish.

Below is the same comparison with the reasoning behind each call, and, for the directions I carried further, the real high-fidelity screens rather than wireframes.

✕ Rejected

Pure chat interface

No structure, conversation-driven shopping from the first screen. Pros: maximally flexible, handles any input. Cons: felt like talking to an assistant rather than shopping. Refining prompts and scrolling through responses didn't reduce effort, it just relocated the effort into conversation. It was also the direction that would have taken longest to build well, despite being the one I had least conviction would actually solve the problem.

I ended up building this out anyway, not as a shipped direction, but as a deliberate side-by-side comparison inside the prototype itself. Nine back-and-forth questions with a generic "Gift Bot," and still no results, versus two steps in Dearly. Seeing that failure mode rendered as an actual, scrollable conversation, rather than just describing it, made the case for the chosen direction far more convincingly than the paragraph above does on its own.

~ Rejected

AI recommendations layered on the existing category structure

Keep a conventional e-commerce architecture, add AI suggestions on top. Pros: lower-risk, familiar to build and to use. Cons: didn't actually solve anything. The underlying architecture was still category-first, this was decorating the old model with AI rather than rethinking it, and it wouldn't have addressed either persona's actual frustration.

✓ Chosen

Intent-first from the ground up

The interface interprets what someone's trying to do and shapes itself around that, rather than asking the user to shape their request around the interface. It most directly answered the design question, and let me scope a small, testable version rather than a sprawling one: a single input, one clarifying step if needed, and curated results.

{/* 7 — MOODBOARD */}

Building the moodboard

Before moving into high-fidelity work, I pulled visual direction from a few sources, each chosen for a different reason. This is honestly how I like to work, I'd rather collect from several different lenses than default to whichever tool is fastest: Pinterest for colour and trend forecasting, Mobbin for real production patterns and current interaction conventions, and Dribbble and Behance for early visual direction and mood.

{['Pinterest', 'Mobbin', 'Dribbble', 'Behance'].map((t, i) => {t})}

I gave myself a small, self-imposed challenge here too: work Pinterest's 2026 colour forecast, jade and cool blue, into the palette, partly to push myself outside my usual choices. It's a small thing, but curiosity shows up as much in these little constraints designers set for themselves as it does in the big process decisions.

That went into a single moodboard in Figma, which became the brief for the next stage.

{/* 8 — PROTOTYPING WITH CLAUDE DESIGN */}

Prototyping with Claude Design

This is the section where the second question I set out to answer, how much of the thinking an AI tool can genuinely carry versus how much still has to come from me, gets tested directly.

Once I'd chosen the intent-first direction, I deliberately chose not to hand-build every screen from scratch straight away. I wanted to see what happened if I treated the prompt itself as the first design artefact, so I moved into high-fidelity exploration using Claude Design.

I turned the concept into a structured design prompt covering five things: intent over categories, gift discovery as the core goal, explicitly avoiding both traditional e-commerce patterns and pure chat-first patterns, keeping the experience minimal and decision-focused, and grounding the visuals in the jade and cool blue moodboard. Writing that prompt was its own small experiment, I was curious whether naming the constraints I'd normally hold in my head while sketching would produce something closer to my actual intent, or something generic.

From that single prompt, Claude Design generated two distinct high-fidelity directions for a mobile experience: one leaned into conversation, refining intent through dialogue, the other was more structured, converting intent into curated, decision-ready product suggestions more quickly. Seeing two meaningfully different interpretations of the same brief come back from one prompt was useful in itself, it's a fast way to see how differently a single idea can be read, faster than I'd get sketching two directions by hand. I chose the structured direction, it suited both personas better: Ellie gets to a decision fast, and Sam gets guided rather than dropped into another open-ended chat.

{/* Direction A/B screens hidden until real screenshots are ready, was just showing raw placeholder label text, looked broken. Restore by un-commenting once the real Claude Design outputs are in hand.

Direction A: conversational, refining intent through dialogue

Direction B: structured, chosen. Intent input → curated results

*/}

Where I became more critical of AI as a design tool: the quality of what comes out depends entirely on how well the prompt is structured. When intent or constraints are vague, the output drifts back towards familiar patterns, chat interfaces, product grids, the exact conventions I was trying to move away from. Prompting itself became a form of design thinking, I was shaping the boundaries of the solution before a single pixel was generated. That was the most useful thing I learned from this whole exercise, not a specific screen, but the realisation that vague prompts and vague briefs fail for the same reason.

What this was actually good for: speed of exploration, surfacing directions I might not have sketched by hand first, and cutting time spent on repetitive UI execution so I could spend it evaluating whether a direction actually fit the personas.

What it wasn't: a replacement for craft or judgement. It can default to existing UI conventions when unchallenged, and it doesn't replace the depth of decision-making that comes from manually working through a flow. This wasn't my final design output, it was a fast, honest way to test and visualise a direction before committing more time to it, and exactly the kind of experiment I want to keep running as these tools change.

{/* 9 — THE HARDEST DESIGN PROBLEM */}

The hardest design problem

Handling vague intent

The core challenge sits with inputs like "something nice for my mum", real intent, but not yet actionable. It could mean candles, gardening tools, jewellery, almost anything.

My first instinct was to fall back on structure, show categories, let the user refine from there. I rejected that, because it would have quietly reintroduced the exact category-browsing experience the whole project was arguing against.

Instead, the resolution is a single clarifying question before showing results, one targeted question, not a form. That's the mechanic the riskiest assumption above is really about: whether one question is enough to resolve ambiguity without the experience sliding back into a browsing pattern. I don't have validated evidence yet that one question is the right number, which is exactly why it's the first thing I'd test, not the last.

The three-step flow

The experience breaks into three distinct moments, each designed to reduce friction as the user moves from intent to decision:

Why three steps, not two? Intent alone is often ambiguous. Jumping straight to results risks either guessing wrong (poor recommendations, eroded trust) or showing too many options (browser-like overwhelm). One clarifying question sits in the middle: it's targeted enough to actually refine the search, but not structured enough to feel like you're back in a traditional browsing flow.

The interaction design: Notice how the clarifying question keeps the original intent visible as editable chips ("my mum", "gardening", "$50") rather than hiding it. That was a deliberate choice, it reassures the user the system heard them correctly, and lets them correct a misread without starting over. The question itself, "What's her style?", only appears once the system has enough to ask something specific, it's not a generic form field.

This changed how I think about the designer's job here. I wasn't only designing interfaces, I was designing how a system interprets intent and decides what to ask next.

{/* 9.5 — TRY IT YOURSELF (live embed) */}

Try it yourself

This isn't a mockup, it's a working prototype

Every screen above is a real, clickable build, not a static comp. Type your own intent below, answer the clarifying question, and see what Dearly suggests, start to finish.

{/* 10 — CURRENT STATE AND WHAT'S NEXT */}

Current state and what's next

Where this stands: a validated design question, two personas grounded in a real observed behaviour shift, three directions evaluated with clear reasons for rejecting two of them, and a chosen direction taken to a high-fidelity, structured mobile prototype, not a moodboard, not a deck of ideas, an actual decision-ready UI. All of it inside a single week, by design, I treated the compressed timeline as a forcing function rather than something to push back against.

The full user flow is built out and interactive: a user opens the app to a hero screen with the Dearly logo and a "Get started" call-to-action. From there, they enter their intent in natural language ("A gift for my mum who loves gardening under $50"), and the system responds with either a single clarifying question if it needs more specificity, or immediately shows curated results. From the results grid, they can add a gift straight to cart, and the flow closes with an order confirmation, delivery estimate included. The entire experience is designed to feel fast and intentional, not exploratory.

What it isn't yet: tested with real people. The honest next step is validation: how specific does someone need to be before the system can respond meaningfully, where does intent become too vague for one clarifying question to resolve, and how much should the interface guide before it's just categories again wearing a different UI. I'd want to test the clarifying-question mechanic specifically, cheaply, with real intent prompts from people who aren't me, before investing further design time in surface polish.

{/* 11 — WHAT I LEARNED */}

What I learned

✦Prompting a design tool well is itself a design decision, not a shortcut around one

✦The riskiest part of an intent-first product isn't the visual design, it's whether the system can resolve ambiguity in one step without collapsing back into the pattern it's trying to replace

✦A self-directed project still needs scoping discipline. Without an external deadline or client to push back, it's easy to let exploration substitute for a decision, three directions evaluated and one rejected clearly is more valuable than five directions left open

✦Designing for intent means designing the questions a system asks, not just the answers it shows

✦Curiosity is more useful when it's structured. Setting myself small constraints, a colour challenge, a five-point prompt, a single clarifying question, gave the exploration somewhere to land instead of staying open-ended indefinitely

{/* 12 — REFLECTION */}

Reflection

Dearly started as a personal observation and turned into two things at once: a genuine test of intent-first commerce, and a genuine test of how I want to work with AI tools going forward. The useful discipline wasn't the moodboard or the visual direction, it was naming the riskiest assumption early, ruling out two directions with clear reasoning, and taking the third all the way to a testable, high-fidelity prototype rather than leaving it as an idea.

I'm not done being curious about this. I still don't know if one clarifying question is the right number, I still don't know how differently Claude Design would have interpreted a looser prompt, and I still want to keep testing where these tools genuinely extend my thinking versus where they just move faster in the same direction I'd have gone anyway. That's the part of this project I'd want to keep pulling on next.

{/* 13 — NEXT PROJECT */}

{ e.preventDefault(); onNav('imprint'); }}>

Next · back to work

Imprint

→