Designing and shipping an AI-native founder OS.
A momentum engine for life sciences founders.
An AI-native operating system that learns a venture once, then uses that context in every decision.
The problem
Early-stage founders, especially in regulated fields like life sciences, make compounding, high-stakes decisions with fragmented context and tools that forget them between sessions. And the institutions meant to help (accelerators, VCs, universities, labs) can't personalize that support across dozens of founders at once.
the.garage attacks both ends: an operating system that learns a venture once, grounds its answers in real regulatory and funding knowledge, and remembers every decision and why it was made. Underneath, a layer that lets institutions support founders at scale. The whole system is built around one line:
Context before intelligence before execution.
It's a momentum engine for life sciences founders, built for the path they actually walk.
What I did
I co-founded the.garage and designed it end to end, across IA, UX, interface, motion, and brand, then wrote most of the initial production front-end (TypeScript, React, Next.js on Vercel). A senior product designer worked with me through the early exploration, and a developer built the backend alongside it. The codebase has kept growing with the team since.
What's rare is the seam that isn't there: the same person shaped the product, designed the system, and shipped the code. No handoff, no translation loss between a design file and a build, which is part of why it moved as fast as it did.
How it took shape
A chat can give a founder a smart answer and still leave the real work undone: turning that answer into a decision, a plan, a task. So the core interaction is built the other way around: the AI produces things you can act on and commit, not paragraphs to read. That's the card system.
And once decisions are objects, keeping them is the obvious next step. Each one holds its context and its provenance, so the company's reasoning compounds instead of scrolling away. That's the memory layer. Problem to product, the logic is one straight line: remember, then help.
It learns the venture first
The product opens with onboarding, but onboarding here is an agent, not a form. You describe what you're working on, typed or spoken, and the AI interviews you: it asks, listens, and pulls structured context out of plain conversation. A company profile assembles itself as you talk (description, stage, sector, funding, team), with a meter tracking how well it knows you. No fields, no setup wizard; the agent does that work.
And it pushes like an operator. Give it a vague goal, “grow Ops and Sales,” and it asks a sharper one: if we check in 90 days from now and it went well, what specifically happened? Hand it a pitch deck and it reads that too, parsed and folded into the same picture.
By the time you reach the workspace, it already understands the venture. That's the foundation the rest stands on: context before intelligence works only because the agent builds the context first, without making the founder do it.
the.workshop is the command center: an AI command bar over your ventures, a roadmap from IP protection to Series A, work grouped by lane (Legal, Regulatory, GTM), a readiness meter for the next milestone, plus a knowledge library and a people/CRM view. One founder can run several ventures from one place.
the.workbench
Open any goal and you enter a workbench.
Around the edges is what real work needs: the goal, the decisions already made, the source material the AI is using, the plan, and what's still missing. It auto-saves, branches, and keeps a history.
The key idea is in the middle: the AI doesn't answer in paragraphs. It answers in cards you can act on. I designed a set of card types the model composes instead of prose, each one a small, finishable interface:
- Decision card a recommendation as one clear choice; accept it and it queues to commit, like code.
- Trade-off matrix drag what you care about (speed, predictable revenue, adoption friction, defensibility) and the options re-rank live. It shows its work; you steer, then commit.
- Plan card a real plan: numbered steps, owners, durations, dependencies. Commit it, don't retype it.
- Expert card a specific person (a patent attorney, a former FDA reviewer), why they fit, and a way to reach them.
- Template card a structured deliverable, like a 510(k) pre-submission package, already scaffolded.
- Check-in card a revisit date, framed as a nudge to reflect, not a deadline.
Some cards structure the thinking: a decision, a trade-off, a plan. Others connect the founder to the real world (a person to call, a document to file, a tool to adopt, even a video or podcast to learn from), so an answer ends in something done, not just read.
Building this meant designing a system, not a screen: one consistent way for the AI to hand work to a person, across 14 card types, calm enough to use all day.
Memory you can audit
Most AI memory is a black box. the.garage takes the opposite approach: context you can see, question, and revise.
Every choice lands in a decision log, stamped with where it came from (founder, AI, or system), and you can commit, revert, or supersede it. The company's thinking has a paper trail.
It matters most when past and present conflict. Make a pricing call in March; when two pilot sites push back in May, the.garage resurfaces that decision next to the new evidence and asks: reaffirm, revise, or revert? Context isn't just stored. It comes back when it matters.
How it's built
the.garage is a real production app, front to back: a Next.js 16 / React 19 front-end on Vercel (strict TypeScript) over a Neon Postgres database, with Google and email auth, voice input, six deployment environments, and a release-notes system feeding a live changelog. I wrote the front-end; the backend is shared work.
Under the interface is a real component library: command bars, context rails, task modals, milestone timelines, and the full set of result cards (14 types), all in one visual language, on a CSS design-token system.
Behind the cards is the.engine, the product's context layer. Before the model answers, it reads intent and assembles the right context: company, profile, text parsed from uploaded documents, and authoritative regulatory and funding knowledge (FDA, CMS, SBIR and more) pulled from a dedicated vector service. Then it routes to a provider chain (Claude primary, an OpenAI fallback behind it) and streams back. Answers come as before/after proposals you accept and commit, and every commit writes to an immutable event log that links decisions into a graph, which is what makes “context, then intelligence, then execution” real instead of a slogan.
I built the front-end with an AI-native workflow (Claude Code, Cursor). That's the point: it let a designer cover a surface this large without the craft slipping.
What it took
About four months, from blank repo to a product you can log into and run a company inside.
the.garage is pre-launch, structuring its first pilots, so the measure here isn't users or revenue. It's how much production-grade product got designed and shipped, and how fast: an AI that learns the venture, a multi-venture command center, a workbench with 14 card types, an auditable memory system, auth, voice, and a release pipeline.
That's the bet, shipped: designed end to end.
You can log in.
Launch Live ProductFraming the strategy to scale a boutique healthcare practice into a national-ready model.
Scaling a boutique practice into a national-ready model, without losing the human part.
A six-week, AI-first product vision for high-touch care that can actually scale.
the problem
Paradigm Health had built something most healthcare never manages: care that feels continuous, human, and genuinely connected. Patients aren't passed through a system; they're understood within it.
But that quality lived in people, not infrastructure. It held together because individuals held it together. The moment you try to grow (more patients, more clinicians, more locations), the thing that made it special is the first thing to break.
Designed for people. Not built to scale. The hard part wasn't improving the care. It was carrying it forward without hollowing it out.
what i did
I led this end to end and hands-on (the research and strategy, the frameworks, the UX, the interface, and the AI direction), with a product designer alongside me about a quarter of the time and a motion designer for a few key moments. Six weeks, blank page to a vision the founders could see and believe.
It ran as a disciplined arc, not a brainstorm: a Discovery phase of stakeholder, patient, and staff interviews, experiencing the service firsthand as a patient, and baselining the practice against three high-impact metrics (Satisfaction, Efficiency, Outcomes), leading into Definition, where the insights became frameworks and a market-ready opportunity, into a Vision / Proof of Concept that made the future tangible.
The work paired strategy with the visuals to make it real: not a slide deck of recommendations, but a product vision you could look at: responsive web POCs and scalable workflow designs that showed Paradigm what their practice becomes at scale.
Strategy nobody can picture is just an opinion. The job was to make the future concrete enough to fund and build.
the approach
You can't redesign a system you've only seen from the outside. So I stepped into the reality of care delivery (not the idealized version, but the one shaped by clinicians, care teams, and the pressures around them) and mapped where it strains: where things slow down, where information fragments, where a patient quietly falls out of sync with the system meant to support them.
A handful of insights set the direction: patients want time, trust, and clarity; the team was carrying too much administrative burden, with documentation and manual workflows pulling clinicians off patients; regulatory compliance could be a catalyst, not a constraint; and technology was the lever, but only if it served the model rather than complicating it.
What surfaced wasn't a technical problem. It was a structural one: how do you introduce intelligence that supports the human connection instead of competing with it?
the idea
The instinct in healthcare is to buy software and hope it helps. We did the opposite. The vision was to codify the practice's best work into frameworks first (repeatable, human-centered workflows) and let technology, including AI, emerge as the natural byproduct of those frameworks rather than the starting point. Three principles kept it honest: purpose before technology, simplicity over complexity, measured impact.
That gave the AI a clear job. Not a chatbot bolted onto a clinic. An intelligence layer that supercharges doctors: listening to and drafting notes in real time, aggregating the latest clinical research, surfacing the right patient context at the moment of care, and lifting the documentation and admin weight off the team, so clinicians spend their time on patients, not paperwork. Always supporting human judgment, never replacing it.
AI shouldn't make care feel automated. Done right, it's what lets care feel human at scale.
Underneath sat three frameworks that carried the vision from idea to operating model: the Paradigm Journey (mapping and prioritizing every touchpoint across patient, staff, and doctor), the Empowerment System (intuitive tools for staff, actionable care plans for patients), and the Adaptive Organization (aligning tasks, people, structure, and culture to scale without diluting the care). The POCs made it concrete. A connected system designed around the flow of care: patients supported without navigating complexity, clinicians acting with clarity instead of interpretation, care teams working from shared visibility instead of silos.
what it produced
In six weeks, the engagement delivered a foundation Paradigm could move on:
- A single, cohesive product vision for high-touch care built to scale across locations.
- Three operating frameworks the Paradigm Journey, the Empowerment System, and the Adaptive Organization, which turn the vision into a repeatable way of working.
- Responsive web POCs including the doctor command center, which made the future-state tangible. Not described, shown.
- Scalable workflow designs that preserve the human connection while letting capacity, quality, and clarity grow together.
result
It's vision work, and it reads like it. The measure here isn't users or revenue (nothing shipped). It's whether the founders could see their business's future clearly enough to commit to it. They could.
“You have given us a truly beautiful gift of helping us vision our business and shape us for the future. Your understanding of our practice and industry expertise formed an amazing partnership.”
The boutique experience, made repeatable. The human part, kept intact. That was the whole bet, and we designed the system that makes it possible.
Ambitious ideas, made real,
and recognized.
I take vision → strategy → UX/UI → working product, directed with a cinematic eye. 19 years of craft, building since 2007. Currently building the.garage.
how i work
range
recognition
trusted by
background
Strategist and designer, thinking and prototyping with AI.
Nineteen years taking ambiguous tech from concept to commercialized, award-winning product. Now framing and prototyping with AI, hands-on in the code when it helps, working alongside the teams that build. Currently building the.garage to production.
education
- Fashion Institute of Technology: Graphic Design major, Film minor, Magna Cum Laude
- SUNY Westchester Community College: Visual Communication
- User Interface (UI) Design Certified Faculty, FIT (2020)