Amit Sharma.
Home Working method

AI as a design tool

Most of what gets shown as "AI in design" is a prompt that produces a screen. That is the least useful thing it does. The screen is the cheap part — the decisions behind it are what take the time, and those are the parts a model cannot be accountable for.

So rather than list tools, this page walks one product through my process. A food delivery app: four sides — customer, restaurant, rider, support — sharing one order that changes state eleven times in forty minutes. It is the kind of product I work on, and it is unforgiving about exactly the things AI is and isn't good for.

Working method: A worked example, not a client project. The product is generic; the method is what I actually use.
Discipline
UI/UX and product design
Worked example
Food delivery — customer, restaurant, rider, support
Where it fits
Synthesis, copy, data, documentation, edge cases
Where it doesn't
Judgement, users' words, accountability
Context

The problem

Design tooling gets sold on the visible output. Generate a food delivery app. You will get a hero image of a burger, a category row, a cart. It will look finished and it will be worthless, because none of the hard parts of a delivery product are visible in that screenshot.

The hard parts are: what the restaurant sees when it is 8:40pm and eleven orders are stacked; what the customer sees when the rider has been stationary for six minutes; who is allowed to cancel an order after the food is cooked; and what a menu item called Paneer Butter Masala (Half) — Jain, no onion no garlic does to a table designed against Pizza.

Those are where the time goes. Some of them are mechanical, with a right answer. That is the shape of work worth handing over.

The rule: AI drafts what is cheap to be wrong about. I decide what is expensive to be wrong about.

A wrong first draft of a payment error message costs a minute. A wrong decision about who can cancel an order after pickup costs money, food and a rider's evening.

Process Breakdown

8 Stages in Practice

Walking one 4-sided food delivery order through every phase of product design.

Stage 01 Research Synthesis

Research synthesis

Nine interviews: four restaurant owners, three riders, two frequent customers. Roughly six hours of audio about why orders go late.

Before

Six hours re-reading transcripts, highlighting, retyping quotes into a spreadsheet, then grouping them by hand, usually when I was too tired to group well.

After

Transcripts in, and I ask for recurring themes with the verbatim line each theme rests on. Then I check every quote against the transcript.

What came back that I had missed: Three of the four restaurant owners described the same workaround — they mark an order "preparing" the moment it lands, before touching it, because the timer starts on accept and they are judged on it. That is a design failure disguised as a metric. I found it in the transcript, but I found it because the clustering put those three lines next to each other.

Why it works: Clustering is mechanical. Deciding that this particular cluster is the whole project is not, and that judgement stays with me.

The catch: It will produce a quote that reads plausibly and was never said. Requiring the verbatim line is not a nicety; it is what makes the invention checkable in thirty seconds.

Stage 02 Microcopy & Errors

Microcopy and error states

Before

Payment failed. Please try again.

After

Your HDFC card was declined. The restaurant is holding your order for 8 minutes — pay with another method, or switch to cash on delivery.

Why it works: Writing twenty variants is cheap. Knowing that the useful information here is the order still exists and there is a clock on it is the design decision, and I still make it. The model will happily write twenty polite, useless variants of "please try again" if that is all you ask for.

Rider app, same principle

Before

Location unavailable.

After

We've lost your GPS for 4 minutes. The customer can still see your last position. Turn location back on, or call them from here.

Stage 03 Dense Table Stress Data

Realistic data in dense tables

The restaurant partner's menu manager and live order list — the two densest screens in the product.

Before

Lorem ipsum, "Pizza", "Burger", "John Doe", twelve rows, three-digit prices. Tidy in Figma, broken on day one.

After

400 generated menu rows and 60 order rows built to mirror real conditions.

Stress conditions tested:
  • A 54-character item name with brackets and a Jain modifier
  • An item with 14 add-ons and two required choice groups
  • A ₹0 item (a free add-on the restaurant uses as a note)
  • A customer name in Devanagari next to one in Latin, in the same column
  • An address that is four lines and a landmark instead of a pin
  • A restaurant with 400 items and no categories at all
  • An order that was refunded, re-placed and then partially cancelled

Result: Six layout failures showed up in an afternoon. The worst: the item name column truncated at exactly the point where "no onion no garlic" became invisible, which is the single piece of text a kitchen cannot afford to miss.

Why it works: This is where dense operational interfaces fail, and it is the cheapest class of bug to find before build rather than after.

Stage 04 Layout Exploration

Layout exploration

The live order tracking screen — map, status, rider, ETA, support entry.

Before

Three directions, because three is what fits in a morning.

After

Twelve rough directions in the same morning, ten discarded within minutes.

The honest part: Generated layouts are average by construction; they are assembled from what already exists, which for a delivery app means every competitor's tracking screen. That is genuinely useful, but as the thing to argue against. The direction I kept came from asking why the map is the biggest element when the customer's actual question is "is it coming" — and the answer is that the map reassures precisely when nothing else can. That argument is not in any dataset. It came out of the rider interviews.

Stage 05 Design System Specs

Design system documentation

The order status pill: 11 states, three sides of the product, different rules about which are visible to whom.

Before

Component built, usage rules never written, and the team asks in Slack instead. A system nobody can read stops being a system.

After

First-draft usage rules, do/don't pairs and a props table produced from the component itself, then corrected by me. Twenty minutes of correction against a day of writing that never happened.

What I still had to write myself: The rule that cancelled and rejected must never share a colour, because the restaurant is measured on one and not the other. That is a business rule wearing a visual-design costume.

Stage 06 State & Permission Matrices

Permissions and state matrices

The part of a four-sided product that always gets missed.

Before

A matrix covering the cases you remembered: customer cancels before accept, restaurant rejects, rider drops.

After

Every combination enumerated: actor (customer / restaurant / rider / support) × order state (11) × payment state (paid, COD, refund pending) × whether the food has been cooked. Then I delete the impossible ones and design the rest.

Unsurfaced states discovered:
  • Rider cancels after pickup, prepaid. Who has the food, who is refunded, and what does the restaurant see?
  • Customer's number is visible to the rider — for how long after delivery, and is it visible to support forever?

Why it matters: Not because the model understood the product, but because it does not get bored on combination 47, and I do.

Stage 07 Accessibility First Pass

Accessibility first pass

Before

Contrast checked at the end, if there was time. In a delivery app the status colours are semantic — green, amber, red mean something operational — so getting them wrong is not cosmetic.

After

Token file in, every pair below 4.5:1 listed, fixed at token level so the whole palette moves at once. The amber "preparing" state failed against both the card background and the map overlay it sits on.

The limit: A machine pass catches contrast ratios and missing labels. It does not catch a rider app where the focus order jumps from the map to the support button and skips "arrived", or a live region that announces the ETA every eight seconds while the customer is trying to read the address. Those need a person, a screen reader, and one hand on a bike.

Stage 08 Developer Handoff

8. Handoff

Before

A Figma file and a call.

After

Drafted acceptance criteria per screen, which I then edit. For order tracking alone that meant naming the states that normally get discovered in sprint review: rider GPS lost, restaurant rejects after payment, address outside the delivery zone, ETA passed and nothing has changed, order delivered while the app was closed.

Outcome: Developers get an explicit list of edge-case behaviors rather than guessing from static screens.

Tooling Matrix

The tools I use

The tool matters less than the job. Most of these would swap out tomorrow without changing anything above. Listed by what each one is actually for, and where it lets me down.

Tool What I use it for Why this one Where it lets me down
Claude logo Claude Research synthesis (1), permission and state matrices (6), acceptance criteria (8) Takes nine transcripts in one go and holds the thread across them; will say when a theme isn't supported by the text rather than agreeing Wordy by default. Needs to be told to cut.
ChatGPT logo ChatGPT Microcopy variants (2), generated stress data (3), placeholder and empty-state imagery Fastest for volume — twenty error-message variants in seconds — and image generation sits in the same place Confident about UX conventions it has half-remembered. Every claim needs checking.
Gemini logo Gemini Long PDFs and spec documents, competitor teardowns, anything already in Google Docs or Sheets Handles a 60-page requirements document without losing the middle Weakest of the three on tone in interface copy.
Strict Boundaries

Where I keep it out

Client and user data: Nothing under NDA, and no real customer transcript with a phone number in it, goes into a public tool. This is a rule, not a preference, and it removes some of the most tempting uses.
Deciding what to build: Whether to fix restaurant acceptance or customer tracking first is a conversation with the people who carry the consequences.
Users' actual words: A paraphrase is not a quote, and research that reports paraphrases is not research.
The final structure of a multi-sided product: Who owns an order and who may act on it lives in the business and in the law, not in the model.
Anything I would have to defend in a room: If I cannot explain how a decision was reached, it is not a decision — it is a guess with good grammar.