From curiosity to durable AI-native workflows.
The once spark-deadening space between a strong idea and a shipped product is smaller than ever. My work now keeps design closer to the data, schema, science, evaluation, delight, and 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
- Provenance and reasoning are captured as the work happens
- Design-system updates flow from stable product patterns, not memory
- Claude Code skills, plugins, and routines compound team capability over time
Reasoning, build, knowledge, design — one connected system.
ChatGPT, Claude, Claude Code skills, GitHub-sourced skill libraries, GitHub PR workflows, Codex, Lovable, TanStack Start, Notion, Obsidian, Figma Make, and Figma MCP are not a tool pile. They are the rails the work runs on.
- ChatGPT
- Claude Chat + Claude Cowork
- Claude Code research skills
- Lovable
- Codex
- Claude Code
- GitHub PR/review skills
- TanStack Start
- Notion
- Obsidian
- 2,265-page FieldRules artifact archive
- Claude memory skill
- GitHub-sourced Claude skills
- Recurring coherence routines
- Lovable
- Figma Make
- Figma MCP
- Claude Code frontend skill
- Lovable + Codex + TanStack loops
The workflow itself became the product surface.
This is the shift I want to help teams make: AI stops being a chat window and becomes a set of governed, reusable workflows that designers can understand, run, inspect, and eventually own.
Active skills and routines
Project-scoped Claude and Claude Code workflows for elicitation, evals, backlog intelligence, design-system automation, component test scripting, schema sync, Storybook parity, build/deploy, and signal capture.
Indexed artifacts
The FieldRules Notion/Obsidian system spans strategy, product, operations, infrastructure, pilots, Jira snapshots, decision logs, skills, and canonical alignment docs.
Layer agentic loop
Research to sketch, friendly eval, adversarial eval, design-system promotion, deployment, signal capture, and model feedback routing.
Drift detection habit
Jira, Notion, GitHub, Supabase, Vercel, Storybook, TanStack routes, and product surfaces are treated as connected systems that can fall out of sync.
Autonomous build cadence
Prototype and schema routines move the product forward while leaving PRs, summaries, and reviewable artifacts behind.
Concrete before and after.
The test is not whether I can prompt well. The test is whether the old workflow is gone because the new one is better, inspectable, and durable.
Reusable patterns that travel with the team.
FieldRules run loop
A seven-layer agentic loop moves from research input to UI sketches, synthetic-persona evals, adversarial checks, design-system promotion, pilot signal tracking, and next-cycle model-feedback briefs.
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.
Helm action 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 Helm principles, Decision Lens, 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, repo routines, and TanStack-aware implementation loops turn prompting into reusable operating 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.
A live example of designing the operating system, not just the interface.
The protected Helm case study is where the process becomes visible: a design workspace structured so AI agents can enter through a canonical start page, understand the product model, run repeatable skills, and leave behind reviewable artifacts instead of loose chat output.
This is the part I know how to scale: convert the hidden labor of design into durable routines, shared evidence, and team-owned tools.
Unlock Helm case study →A canonical front door tells any human or AI agent how the workspace works, which sources matter, and what to read first.
Every prototype action is tracked by trigger, surface, workflow, owner, decision type, and review status.
Product language becomes a living system, mapped to persona, scenario, severity, and ship-readiness.
Agent-assisted reviews turn judgment into repeatable findings, not vibes trapped in a single critique doc.
Quality gates are scored and repeatable, so design confidence improves instead of resetting every sprint.
Product entities, states, relationships, and sources of truth stay visible as the prototype and strategy evolve.
How I coach teams from curiosity to durable practice.
- 01
Curiosity
Start 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-native tool that earns trust through results, not promises.
- 04
Quality gates
Add evals, provenance, 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. Move to the next bottleneck.
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.