Akash Kalsi~/akash-kalsi
Akash Kalsi · UI/UX Lead · Mindbowser · Panchkula, IN

The distance between deciding something and it being real —

a handoff.
now it's
a branch.

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.

follow the thread
§1 · carrier oneClaude Chat
one project, one conversation

Everything we hear, read or decide goes into one thread.

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.

01

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.

02

Discovery, on the record

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 → thread
03
artefact

The feature list

Built from the whole context. One tab per role, grouped by section — screens, data points, purpose, actions, modals. Never one combined list.

04
artefact

The workflow diagram

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.

Client approval — the gate.
They sign the list and the diagram. Only now does the thread change carrier.
the shift · chat → code

Chat and Code share no memory. The context is carried across by hand.

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.

CLAUDE.md PROJECT_BRIEF.md design.md constants.md feature.md + convention files · from the boilerplate

What isn't written down doesn't make it across.

§2 · carrier twoClaude Code
sessions, stitched by handoff files

One feature, one branch, one commit, two pull requests.

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.

design branch — merging here publishes feature/<wave> one commit merge = publish dev PR — theirs to merge, never chased
the wave loop · delivery standard v1.0 · runs for every feature
typechecktsc --noEmit
lint0 errors
prettier--write .
buildread the chunk sizes
05

Review it uncommitted, in a browser

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.

06

Two PRs, two different reviews

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.

07

Verify the deploy — the tick is not the check

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.
— delivery standard v1.0 · §why this exists
§3 · selected workthe problem, the decision,
and the screen

Three products, one process.

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.

The problem — organ viability is measured in hours.

Coordinating a transplant, against the clock.

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.

LifeRelaymy rebuild · not client dataUS healthcaremulti-role
what changed The pitch stopped being “place organs faster” and became place organs faster, and make the fast path defensible — which is what a regulator tightening oversight is asking for.
LifeRelay, my NDA-safe rebuild: a transplant centre’s offer inbox. Two open organ offers each carry a countdown to respond — the first at eight minutes fifty-three seconds, in red — and below them, under the heading “Elapsed without a response”, a third offer whose window closed with no response sent.
01 · the offer inboxshots/plates/liferelay-offers.webp Two offers on the clock, and one that ran out. The dead one is the screen’s real work — it does not just report the failure, it says what to do about it: The window closed before this center answered. The OPO has been told, and can reopen it by phone.
The problem — the marks are gone before anyone reads the work.

Telling a student what it costs, while they can still fix it.

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.

FairMarkclient engagement · name changedAI evaluationI owned the build
what changed A generic “I understand” became Risk Mitigation Plan (10%) — will not receive evidence credit for this criterion. Consent that is specific enough to be worth something to the student and to the institution.
FairMark: the warning dialog a student sees before submitting. It lists three rubric criteria with their weights — Risk Mitigation Plan at ten per cent, tagged HIGH RISK, then Strategic Framework Application at twenty-five and Financial Recommendation at twenty, both MEDIUM RISK — then a note about time remaining, and the choice between “Go back & improve” and “Submit anyway”. Behind it, the report shows sixty-eight per cent rubric coverage.
02 · the dialog before submittingshots-fairmark/plates/fairmark-consent.webp The paragraph above claims this screen prints the price and the remedy in the same breath. It does: 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.
The problem — the deliverable stopped being a file.

Taking Figma out of a design team.

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.

delivery standard v1.0processwhole teampublished as written
A diagram I drew for the team, titled “One thread, day one to handoff”. A braided ribbon runs left to right, green while the work lives in a chat and blue after it crosses into code, with a labelled tributary for every call, email and review that joins it, a flagged crossing point in the middle, and artefact markers hanging below the line.
03 · the threadshots-delivery/plates/delivery-thread.webp Not a screen — the drawing the team works from. The whole standard is the sentence at the crossing: 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.
§4 · on papercounted, not claimed
4y 10m
at Mindbowser —
designer → senior → lead
4
gates before
every push
40+
design sprints —
most in US healthcare
3
annual company awards,
three years running
2
master's degrees —
the second in UX + AI

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.

§5 · historya career, committed

A career, in commitsgit log --oneline

~/akash-kalsi $ git log --oneline --graph
*f2a9b41(HEAD → open/to-work) feat(next): looking for the room where this is normalnow
*b4d02aafeat(process): delivery standard v1.0 — figma removed from the pipelineaug 2026
*3e5a90fdocs(degree): M.Des UX Design, AI specialisation — JGU · alongside the day job2026
*8c17d3efeat(role): promoted — UI/UX Leadmay 2026
*91cc7f0feat(role): promoted — Senior UI/UX Designermay 2025
*4d8e2b9feat(recognition): annual company award — third year running×3
*a7f31c5feat(craft): 40+ design sprints shipped · US healthcareongoing
*0b6d94efeat(career): joined Mindbowser — UI/UX Designernov 2021
*c59e01dinit(career): first design role — DarkLion Studiomar 2021
§6 · the domainwhere I'm deep

US healthcare, where getting it wrong is expensive.

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.

Accessibility
Not a checklist at the end — in healthcare it's frequently the constraint that reshapes the information architecture.
Multi-role systems
Feature lists and flows built per role, never combined. The discipline that stops a platform collapsing into one confused screen.
Regulated workflows
Where copy is a claim, seed data carries authority, and an unbuilt claim in the interface is a defect — not a wording problem.
Stakeholder rooms
Clinicians, PMs and engineering leads disagreeing productively. Getting to a decision is most of the job.
§7 · the humanoff the clock

Selectively extroverted. Reliably obsessive.

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.

snooker cricket Nolan & thrillers Panchkula · IST backend next
Akash Kalsi — navy suit, standing in an office
akash · panchkula
§8 · end of threadthe merge

If your designers ship code — what are you calling them?

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.

feat(team): add akash kalsi
#0001 · akash wants to merge 1 commit into your-team:main from akash:open/to-work
design review — passed · you're looking at it
code review — passed · view source, it's hand-written
gates — 4/4 · typecheck · lint · prettier · build
Merge pull request merging opens your mail client · [email protected]