Intake — whatever exists so far
One Claude Project per client. The first message carries every document sales hands over. That is the start of the thread.
The distance between deciding something and it being real —
I lead a design team that stopped delivering Figma files. We design directly in Claude Code, in the client's repo — and I wrote the delivery standard that makes that safe for complex, regulated products. The proving ground: US healthcare, where getting it wrong is expensive.
A design sprint fails in the gaps — the decision made on a call nobody wrote down, the constraint that lived in one person's head. So we removed the gaps. Nothing is allowed to live only in someone's head.
Every document, call, email and correction goes into the same running conversation, and the artefacts the client signs are built straight out of it — so the sheet and the conversation can never drift apart.
One Claude Project per client. The first message carries every document sales hands over. That is the start of the thread.
Every client call is recorded and transcribed. Internal calls too. Each transcript goes into the same chat — after I've read it and corrected what the model misheard. My brain is the checkpoint.
EPICO → transcript → threadBuilt from the whole context. One tab per role, grouped by section — screens, data points, purpose, actions, modals. Never one combined list.
Feature list, information architecture and user flow in one picture — per role. The loop is always the same: internal review → senior → client → feedback back into the thread.
The most fragile point in the whole flow. Nothing crosses on its own — it crosses on .md files, into every repo, on the right branch.
What isn't written down doesn't make it across.
The coded deliverable auto-deploys to the client's review site, so one fact drives everything: a merge is a publication. The standard I wrote has two jobs beyond tidy code — make an accidental publication impossible, and make a bad deploy detectable rather than merely unlikely.
Against the spec — never by reading the diff. Defects that pass typecheck, lint and build while being plainly wrong on screen are the normal case, not the exception.
The design PR is a publication and it's mine to merge deliberately. The dev PR belongs to the engineering team, on their schedule — a naming comment never holds up a client demo.
A green pipeline says the job ran; it has run green while shipping the wrong build. I diff the deployed asset hashes against my own build. diff local.txt deployed.txt
Nothing in the standard is theoretical. Every warning in it is something that went wrong once — and cost real time to find.
Two of these came out of client engagements. One is under an NDA that isn’t going anywhere, so I rebuilt it from scratch — same problems, same decisions, my own data, on my own domain. On the other I took the client’s name and branding out, because those were never mine to publish. The third had no client on the other side of it at all. Everything below is open; the two client names are the only part I’m holding back.
A multi-role platform for a US transplant network, where a slow screen costs outcomes, not conversions. Roughly one in four kidneys recovered for transplant is never transplanted — the search for a recipient outruns the organ’s shelf life. The engagement is under NDA, so what you can open is my own rebuild of it: same problems, same decisions, none of their data.
The constraint inverted the architecture. The registry that governs allocation has no API for anyone outside it. So the product runs beside it rather than through it, and the coordinator alerts centres directly. The scramble was always manual; a layer over a manual process is the truer fit, not the compromise.
The decision I’d defend. The brief listed favourite centres drive prioritisation as a feature — the precise mechanism the equity literature criticises. I replaced it with criteria centres declare in advance, matched per donor. Same speed, nobody chosen by hand, and every centre left off says why.
The window closed before this center answered. The OPO has been told, and can reopen it by phone.
The student side of an AI evaluation platform for professional education. The engagement isn’t mine to name, so the client’s name and branding came out and the demo you can open is that build, rebranded. A student thinks the job is upload → submit → done; the system needs complete → readable → evaluable before grading can start. Almost every platform reports that gap after submission — when it is a verdict, not information.
The constraint shaped everything. Reading a document with a model is expensive, and the client put that on the table in week one rather than hiding it. So validation splits into three tiers, and the interface is honest about which one you are in: the checks you can act on run while you watch, the expensive one is queued and you are released.
The decision I’d defend. Everyone designs the success and failure states; the warning state is the one that actually costs marks. So the consent dialog names each criterion, prints its exact weight, and states what proceeding costs — then tells you there is still time, and that resubmitting cannot lower your grade.
Will not receive evidence credit for this criterion — 10% of your grade.and, four rows down,
You have 1d 2h left. Resubmitting after review won’t lower your grade.
Not a tooling swap. Once the deliverable is a running app on a branch that auto-deploys to the client, every habit a design team has needs rewriting — how work is reviewed, who may publish, what happens when feedback lands after a merge.
I wrote the standard, versioned it, and taught the team to run it. It’s the only one of the three with no client on the other side of it, so it goes out exactly as written.
Chat and Code don’t share memory. The thread crosses on .md files, into every repo, on the right branch.This site has the same two carriers for the same reason.
M.Des in User Experience Design, AI specialisation — Jindal School of Design & Architecture, O.P. Jindal Global University. Earned in the margins of a full-time job.
Nearly five years of it. Regulated workflows, many roles, real accessibility requirements, and stakeholders who know their domain far better than I know mine. It's the environment that taught me to write everything down. The domain is the proof, not the ceiling — the same discipline carries anywhere the stakes are real.
I'm from Panchkula, near Chandigarh — studied here, live here, never particularly wanted to leave. I did my second master's in the margins of a full-time job: two years of intensives, immersions and a great many late nights.
The thing I'm actually good at is finishing. I like the part most people find tedious — the state nobody designed for, the edge case in the role matrix, the fourth review pass. My work reads as pedantic until the week it saves someone.
Away from the desk: snooker, cricket, and an unreasonable number of Nolan rewatches.
I asked that publicly and never got a good answer. If you're hiring for the thing I actually do — design judgment carried all the way to the merge — let's talk.