Hi, I'm Dmitri.
I design AI-native products
and then I build them.

I came in to reshape design. I ended up shaping how the company's knowledge workers use AI.

I joined a 30-year-old retail tech company with one designer, no design process beyond accessibility and a nascent component library, and a CEO who wanted AI strategy yesterday. I was hired to reshape the design department — I chose AI as the lever. That choice pulled me beyond pure design leadership into operationalizing AI for knowledge workers across the org: the people who actually had to use these tools to do their jobs needed upskilling, workflow redesign, and patterns that worked.

Scroll within frame to see the full pipeline ↓

The whole pipeline on one page — problem framing all the way through to a post-ship learning loop. Open full diagram →

What I walked into

A 30-year-old codebase, hundreds of screens, one designer, and a department whose entire process consisted of an accessibility partner and the early bones of a component library. Meanwhile the CEO wanted AI strategy yesterday. The old way of designing — a Figma file per feature, one designer per screen, hand-off, repeat — wasn't going to scale, and bolting AI onto a broken pipeline would just produce broken output faster. So I stopped trying to make designers work faster and rebuilt the process around an idea I called provenance: every screen we shipped should know exactly where it came from.

The move

I built an 8-phase pipeline that runs from "we have a problem" to "we shipped, and here's what users did with it." Each phase produces an artifact, and every artifact carries a breadcrumb trail back to the problem brief that spawned it. Translation: any teammate can open any spec line in our repo and walk it back to the user research, the design decision, the dev review, and the analytics. Nothing is orphaned. Nothing gets lost.

AI does the heavy lifting where it's good — generating interactive HTML prototypes with edge cases, piping to Figma via MCP, transcribing dev/PM feedback into structured notes. Humans do the heavy lifting where we're good — judgment, edge-case storytelling, the conversations that don't fit in a Jira ticket. An external accessibility partner validates before lock. Production telemetry comes back in and teaches the next design.

What changed

A UI modernization that used to take three weeks now ships in one afternoon. Not because we're cutting corners — because the next designer doesn't have to re-derive the same decisions every time. The system remembers. The team adopted it; this isn't a one-designer party trick.

The clearest test was a webcart redesign: 200+ screens, scoped for 4–6 sprints, delivered with two designers — one of whom was leading the org. The same scope under the previous design model would have required at least two additional senior designers and, by my estimate, 6–8 months of effort. Neither was available. The system closed the gap.

What was hard

AI-augmented design isn't a free lunch. Three things bit us, and shaped how I run the pipeline now:

• Pixel-perfect parity with an existing component library is brutal. Importing a mature library into Claude Code and getting prototypes to honor every token, spacing rule, and state variant — without the model quietly inventing a button — took significantly more guardrails than I expected. We solved it by tightening the prompt contract and treating the library as a constrained vocabulary, not a suggestion.
• Routing transcription into the right node of the knowledge graph requires slow, deliberate upfront work. Dev/PM feedback only stays useful if it lands on the spec line it actually addresses. That meant building the graph carefully, one stable connection at a time — moving fast here corrupts every downstream decision.
• Edge cases have to be documented before the agent can find them. Our webcart redesign turned into 200+ screens. The agent could only generate useful variants once the edge cases — empty states, error paths, partial-data scenarios, permissions branches — were written down somewhere it could retrieve. Documentation stopped being a deliverable and became infrastructure.

What it unlocked

Proving AI inside design earned the mandate to redesign how the company's knowledge workers use AI more broadly. That work became a 9-layer connected intelligence architecture — green-lit by the CEO and IT for company-wide scale. That's Case 05.

I'm designing it. Then I'm building it.

Atelos is a desktop app that turns your scattered notes, docs, and decisions into a vault Claude can actually use — without your data ever leaving your machine. I co-founded it with Daniel Foreman. He owns the heavy backend. I own everything you can see and click — designing the front-end, then orchestrating the React and Electron build through an AI-augmented pipeline I run end-to-end.

The live Electron build, in progress. Real inbox, real captures, real skills strip. Three months ago this was a Figma file — now it's running on my machine and I'm pushing commits to it.

The bet we made

Most AI knowledge tools — Obsidian, Notion, Mem — use vector search to find what's relevant to your prompt. Vector search is great until it isn't, and when it isn't, you don't know why. We bet on something different: a cascading index. Plain markdown files that act as signposts at each folder level, so the AI walks the structure of your vault instead of guessing at it. Deterministic, explainable, and dead simple to debug.

What I do, in order

I run the research. I write the specs. I prototype in HTML. I test the prototype with real users. I take their feedback and rebuild. Then — this is the new part — I orchestrate the Electron and React build that ships: architecture, prompts, integration, debugging, commits. The boundary between "designer" and "engineer" mostly gets in my way these days, so I stopped pretending it was there.

Persona journey map for Sam — one of three personas I built. The fourth column is "anti-personas," the people we explicitly don't build for. Scope discipline, not gatekeeping.

What testing told us

Four user-test sessions across the target personas — a PM director, two product designers, a senior UX designer who hates terminals on principle. Three things came back the same way every time: skills are the strongest hook, project-level organization fills a real gap, and local-first lands as a feature, not a worry. The friction was where you'd want it to be — first-run orientation and the ChatGPT-to-vault mental shift. Both fixable in onboarding without touching the architecture.

"Chats, files, and tasks. I love how it's all separated out. That's such a smart move to parse out those differences." — James, Senior UX Designer, in testing

Kelli — the PM director — had already built her own DIY version of Atelos inside Claude Projects. When she saw the skills strip, she said pre-built skills "would save somebody a lot of hours in setup." That's the toughest persona to convince, validating the wedge unprompted.

Quick Capture — four entry paths, one principle: see it, click it, done. The kind of design problem you don't get to solve unless you also build the thing.

Why I think this matters

Most product orgs have a wall between "the designer who specs it" and "the engineer who ships it." That wall is where AI-native products go to die. I closed it on this one. The same person ran the research, wrote the specs, tested with users, and orchestrated the build that shipped. That's the profile, in one sentence.

I built it. Users loved it. I shut it down anyway.

Focus Agents was a multi-agent platform that turned a researcher's 26-hour synthesis job into 33 minutes. Solo built. Production-ready in six weeks. Six PMs and product designers on a free Pro tier in closed beta. By every standard metric, it was working. So why did I stop? Because I watched what they were actually doing with it. And I couldn't unsee it.

focusagents.io — drop files into Google Drive, get board-ready artifacts back. No prompts. No dashboard.

What it actually did

Three agents, all running production. The Research Strategist took interview transcripts and audio and turned them into a four-artifact strategy package — a Google Slides dossier, an executive summary, a quote library, a how-might-we doc. The Survey Analyzer ate CSVs from Typeform, Qualtrics, or Google Forms and produced a findings deck with PII automatically stripped. The Knowledge Distiller converted PDFs and slides into high-fidelity markdown for AI knowledge vaults. All three scored 4.2–4.5 out of 5 on a 12-dimension quality rubric I ran on every job.

Research Strategist — drop 8 interviews in Google Drive, get a board-ready dossier in 33 minutes. The "no prompts, no dashboard" promise was the whole point.

What it looked like under the hood

Each of those three agents is actually a multi-step pipeline. Below are the live n8n workflows — every node is a step (parse, classify, route, call Claude, structure the output, write to Drive). The squiggly mess is the point: this isn't one prompt, it's a chain of dozens of decisions that turn raw input into something you'd actually hand to a board.

Research Strategist — the agent that turned a 26-hour synthesis job into 33 minutes. Each node is a Claude call, a parser, or a routing decision.

Survey Analyzer — handles mixed-methods data (open-ended + multiple-choice) and strips PII before any of it reaches the model.

Knowledge Distiller — three-pass Claude pipeline that pulls structure, then visual elements, then assembles a fidelity-scored markdown output.

And the platform around it

Three agents alone don't make a product — you also need onboarding, billing, usage limits, and the boring stuff that turns a script into a SaaS. I built that too. Stripe-integrated Pro onboarding, Tally-driven free-tier flow, and a 4-branch usage monitor that decided whether each new job was OK to run, abuse, an anomaly, or hitting a free limit.

Pro tier onboarding — a Stripe webhook fires, the agent provisions a workspace, drops in templates and sample files, and sends the welcome email. About thirty seconds, end to end.

What I learned in the beta

The platform worked. The agents worked. The users — exactly my target ICP — also worked, sort of. They used it to skip the thinking entirely. They didn't engage with the data. They didn't read the dossiers. They forwarded them. The faster I made the synthesis, the less anyone did the synthesis.

I'd written an Empathy & Ethics framework before launch — an architecture-level constraint that said, in essence, this product should augment researchers, not replace the work that makes them researchers. I'd built guardrails into the prompts. Human-in-the-loop. Output traceability. The whole architecture was designed to make empathetic use the default. None of it survived contact with the economics. Once "save 26 hours" was on the table, "engage with what your users said" was always going to lose.

"I had users, and what I observed made me unwilling to scale the pattern." — Why I stopped, in one sentence

What this story is about

I'm including this case study because it tells you three things at once. One: I can solo-ship a production multi-agent platform in six weeks — full Stripe billing, stateless scaling, the works. Two: I notice ethical problems before the press release, not after. Three: when principle and revenue conflict, I pick principle. That third one is rare in AI right now. It's the exact thing AI-native companies say they want in leadership. Some of them actually mean it.

I led design for a $1.3B financial ecosystem.

A Fortune 25 retailer doing $148B a year. Inside it sits the financial services arm — credit, loyalty, money services, compliance, and the screens you see at every checkout kiosk. That whole ecosystem moves $1.3B+ a year. I led design strategy across all of it, managed five designers, and partnered with 10+ teams across the company.

The vision that anchored the MVP

Before any blueprint, before any spec, we ran research and ideation on where this product needed to be in five years. Not a feature list — a directional picture of how the customer's relationship with credit should feel by 2030, and what role the retailer played in it. That picture became the constraint everything downstream had to serve. The MVP wasn't "what's the smallest thing we can ship" — it was "what's the smallest thing we can ship that's a real first step toward that future." Scope discipline came free with the framing: if a feature didn't ladder up to the five-year vision, it didn't make the cut.

What the work actually was

Most of what I did there wasn't pixels. It was getting 10+ teams across the company to agree on what problem we were even solving. Service blueprints became the way I did that. Nine of them, across 150+ touchpoints, mapping how a customer experiences the financial ecosystem from the moment they tap a credit offer in the app to the moment they redeem points at the register six months later.

Once the blueprint was on the wall, the meeting changed. Engineering stopped arguing about their slice. Product stopped arguing about theirs. The conversation moved up a level — what should the customer feel here, what's the trade-off, what do we ship first. The blueprints stopped being deliverables and started being the language the org used to talk about itself.

A focused slice of one of the nine service blueprints. Customer actions on top, frontstage, backstage, and supporting systems below. This is what executives ended up pointing at in funding meetings.

What it shipped to

The Credit Reinvention program — the flagship of the work — touched the application flow, the account creation experience, the dashboard, the offers surface, points, savings. Nine screens that customers used millions of times.

The team part

I held 100% retention through a major org restructuring — not because I'm a magnet, but because the work was strategic enough that designers wanted to stay close to it. We stopped being the team that made screens for other teams. We started being the team that decided what got built.

The early AI signal

Toward the end of my time there I started operationalizing agentic AI workflows — ChatGPT, n8n, Gamma — for research synthesis and executive deck creation. Days became minutes. At the time it felt like a small productivity win. Looking back, it was the prototype of the operating system I'd later build in retail tech and at Focus Agents. Same instinct, earlier, smaller scale.

I gave the company a brain.

Most companies have knowledge somewhere. This one has it connected. I architected a nine-layer system where every business surface — sales pipeline, dev tickets, support history, meeting transcripts, the CEO's strategic priorities — feeds into a single intelligence layer that any team can ask questions of, without ever seeing raw data they shouldn't see.

The simple version

Imagine every Slack you'd ever sent, every meeting you'd ever recorded, every customer ticket your team had ever seen, every dev sprint you'd ever run — all of it sitting in separate locked rooms. Now imagine an agent that can read all those rooms, synthesize what matters, strip out anything sensitive, and post a daily briefing that anyone in the company can read. That's the system. The hard part is making sure the agent only writes things that should be shared, never leaks personal data, and stays accurate over time.

What's under the hood

Beneath the vault network sits the rest of the architecture: schema standards that act as the contract between layers, a path for the CEO's strategic intent to enter the system without exposing private board prep, an agent memory layer (built on Microsoft Foundry) with proper decay and supersession rules, and the twelve enforcement mechanisms that make this an architected platform instead of a wiki.

What people did with it

Once the architecture was up, people started using it without being asked. Four active users became ten as colleagues from sales, engineering, and design pulled themselves in with their own use cases. The CRO looked at it and wrote, in a Teams DM, "I think it's brilliant." That quote opened a conversation about building an internal sales-enablement product on top of the system. We shipped a POC: an AI deck generator that pulls from scraped competitor intel, product knowledge, and real sales-call transcripts, and writes branded pitch decks via conversation. Six to ten hours saved per deck.

"I think it's brilliant." — CRO · Teams DM, May 2026

Why this case is in the portfolio

Most designers who claim AI on their resume mean "I use ChatGPT." This is a different claim. This is designing the AI system at the org-architecture level — vaults, agents, memory, security, authority handling, decay rules. It's the line between someone who's curious about AI and someone you'd trust with platform decisions.