From user journey to durable product practice.
The space between a user insight and a working product can be much smaller now. My work keeps design close to the journey, the data, the schema, the evaluation, the moments of clarity, and the judgment calls that used to be scattered across teams and tools.
Linear, manual, opinion-validated.
- Long discovery cycles before any artifact exists
- Static mockups validated through opinion
- Documentation written after the fact, if at all
- Design system updates trail product reality
- Enablement happens in workshops that decay
Connected, evaluated, compounding.
- Research notes turn into prototypes, evals, tickets, and deployable artifacts
- Live data, schema edges, and evidence layers are part of design from the start
- Sources and reasoning are captured as the work happens
- Design-system updates flow from stable product patterns, not memory
- Reusable skills, plugins, and routines compound team capability over time
Tools arranged around the work.
Discovery, prototyping, validation, documentation, and handoff now happen much closer together. The stack matters when it keeps research, design, memory, and shipping close enough that product judgment survives the handoff.
- GPT Deep Research
- User research sessions
- Observed User Behavior
- User Journey Mapping
- Lovable
- Codex
- Claude Code
- GitHub
- Notion Index & Repository
- Obsidian
- claude-mem
- Design Systems
- Design Token .md files
- Workspace skills and automations
- Lovable
- Figma Make
- Figma MCP
- Figma Design
Design judgment became easier to run and inspect.
Automation is useful when it turns research, critique, product language, quality checks, and handoff into repeatable practices designers and teams can trust.
Active skills and routines
Project-scoped workflows for elicitation, evals, backlog intelligence, design-system automation, component test scripting, schema sync, Storybook parity, build/deploy, and signal capture.
Indexed artifacts
The product knowledge system spans strategy, product, operations, infrastructure, pilots, Jira snapshots, decision logs, skills, and canonical alignment docs.
Layer review loop
Research to sketch, friendly eval, adversarial eval, design-system promotion, deployment, signal capture, and legibility notes.
Drift detection habit
Jira, Notion, GitHub, Supabase, Vercel, Storybook, source docs, and product surfaces are treated as connected systems that can fall out of sync.
Build cadence
Prototype and schema routines move the product forward while leaving PRs, summaries, and reviewable artifacts behind.
Design work made easier to repeat.
The test is whether a better practice replaces a fragile one: clearer, more inspectable, and easier for the team to keep using.
Reusable patterns that travel with the team.
Research-to-prototype loop
A repeatable loop moves from research input to UI sketches, persona checks, adversarial review, design-system promotion, pilot signal tracking, and next-cycle notes.
Prototype stitcher
A twice-daily routine picks the next backlog item, builds the next prototype slice, opens a PR, and posts a Slack + Notion summary for review.
Pattern stability scanner
A nightly skill watches repeated interface patterns and only promotes them after stability, usage, and open-iteration gates are met.
Action inventory logger
A recurring Claude Code skill scans prototype source and live UI, then writes a structured action inventory into Notion.
Copy atlas refresh
A repeatable routine inventories product language by persona, surface, workflow, scenario, severity, and review status.
Design critique skill
A reusable agent reviews product surfaces against product principles, decision lenses, personas, NN/g heuristics, and AI-interaction patterns.
Evals and quality cadence
Design quality is treated as a scored, recurring practice: per-change, weekly, pre-release, and quarterly.
Claude Code plugin workflow
Claude Code plugins, GitHub PR/review skills, and repo routines turn prompting into reusable product and design infrastructure.
Artifact coherence system
Notion, Obsidian, Jira, GitHub, Storybook, and product artifacts are treated as a living system: audited for stale references, missing links, duplicate docs, and drift from canonical strategy.
GitHub review workflow
Branching, PR summaries, review-comment handling, CI triage, and push/publish checks become part of the design delivery loop.
Playbook documentation
Each transformation is documented as a portable playbook so the pattern travels with the team.
How I coach teams from curiosity to durable practice.
- 01
Curiosity
Begin with a real piece of work the team already does. Make it visible end to end.
- 02
First contact
Pair on one routine inside the existing stack. No new tools, no theatrics.
- 03
Working tool
Build a small AI-assisted tool that earns trust through results, not promises.
- 04
Quality gates
Add evals, source checks, and human review. Trust becomes legible to the org.
- 05
Routines
Convert the new pattern into a routine the team owns and runs without me.
- 06
Durable practice
Hand off the playbook. Carry the pattern into the next high-friction decision point.
Quality, trust, provenance, and human review.
Every AI output traces back to its inputs, reasoning, and reviewer.
Synthetic and adversarial evaluations run before and after any change.
Explicit gates where humans confirm, override, or annotate.
Shared, written standards that survive personnel changes.