I turn emerging technologies into coherent product experiences.

For more than 20 years, I’ve worked at the intersection of product strategy, interaction design, research, technology, and organizational leadership, helping teams understand complex systems and turn them into products people can actually use.

I’ve led large design organizations at Salesforce, built a UX practice from the ground up at Sequence, and now work hands-on with AI, biometric sensing, machine learning, and new ways of designing through working software.

This GitHub is where that hands-on part of my practice lives.

The boundary between designing a product and building enough of it to understand the product is changing.

I increasingly use code, AI development tools, hardware, APIs, and working prototypes as design materials. They let me explore questions that are difficult to answer in static mockups:

• What should an AI agent do when it is uncertain?
• When should a system interrupt someone, and when should it remain ambient?
• How should product history behave when the underlying data changes?
• How do we preserve human control when software becomes more autonomous?
• How do design decisions survive the transition from Figma into implementation?
• What becomes possible when a designer can prototype the actual system rather than a representation of it?

The projects here are experiments in answering questions like these.

I use AI coding tools such as Claude Code and Codex extensively as implementation partners. I define the product problem, interaction model, system behavior, and acceptance criteria, then use these tools to help implement, test, inspect, and iterate on working software. The value I bring is not typing code faster. It is deciding what should exist, how it should behave, what matters to the person using it, and whether the resulting system actually works as an experience.

Product design expressed as a working native iOS application.

A workout tracker built around a deceptively simple product principle: your history should remain trustworthy.

Workout plans should be easy to change. Completed workouts should not silently change with them.

That principle shapes the experience all the way down through the system: historical sessions are immutable, changes create new versions rather than rewriting the past, corrections preserve original records, and destructive operations are deliberately constrained.

The project explores how product principles can become interaction patterns, state models, data architecture, and ultimately working software.

Product design · SwiftUI · Interaction design · Data integrity · Design systems

A small design system connecting design intent to implementation.

The system provides a shared vocabulary for color, typography, spacing, radius, elevation, and semantic roles across my portfolio and product experiments.

Rather than treating Figma and code as independent sources of truth, the project explores design tokens as an intermediate layer that allows design decisions to remain recognizable as they move into implementation.

The larger question is one I’ve worked with throughout my career: how do you create enough system to produce coherence without creating so much system that it slows down design?

Design systems · Design tokens · Figma · Design engineering

An ambient interface for working with AI agents.

When several AI agents are running at once, the important question is not simply what are they doing?

It is:

Does one of them need me?

VibeSignal translates agent state into a peripheral visual language using a physical USB light and onscreen signals. Working, waiting for human input, finished, and error states are deliberately distinguished so the interface can communicate without demanding constant attention.

Using the system exposed false signals in the original state model, which led to changes in how agent events are interpreted. That iteration is the interesting part of the project: hypothesis → working prototype → lived use → revised interaction model.

It is an exploration of a UX problem I expect to become increasingly important as agentic software develops: designing the relationship between human attention and autonomous systems.

AI agents · Human-computer interaction · Ambient interfaces · Claude Code · Codex

Some of my most technically ambitious work lives in private repositories.

At Senstream, where I lead User Experience, I work with a multisensor wearable that captures signals including PPG, EDA, ECG, temperature, and motion.

My work spans the experience around those signals as well as prototypes that reach much deeper into the system: Bluetooth-connected hardware, real-time data capture, signal processing, machine-learning inference, researcher workflows, and translating raw physiological data into information people can understand and act on.

That work reinforces something I’ve learned repeatedly:

The harder the underlying technology is, the more important it becomes to design from the human experience backward.

I led design for AI capabilities embedded directly into Sales Cloud, bringing machine learning and generative AI into the workflows where salespeople already worked.

That included Conversational Intelligence, which analyzed calls and meetings to surface insights from customer conversations, as well as later generative AI experiences for assistance, summarization, and communication.

I also led design through other major product shifts, including Salesforce's move into product-led growth and deeper integration between Sales Cloud and Slack.

Alongside the product work, I led large design organizations, including a 30+ person advisory design organization and a 15-person Sales Cloud team.

I built Sequence's first UX organization from the ground up, growing it to 15 UX designers, researchers, and information architects.

The team helped companies understand emerging technologies, envision what they could become as products, and carry those ideas through design and launch.

Sequence grew from a brand-focused agency into a product consultancy and was ultimately acquired by Salesforce.

My career has included consumer products, enterprise SaaS, financial services, connected devices, mobile applications, marketplaces, healthcare and wellness, and emerging technology.

One early example was OpenTable, where our team became its outsourced product design group. I designed its mobile applications and first browser-based restaurant-management experiences, helping move restaurant operations beyond dedicated in-house terminals.

I’m less interested in adding AI to existing interfaces than in asking how AI changes the structure of the product itself.

That means thinking about:

Agency
What should the system be allowed to do on someone's behalf?

Control
Where does a person need to review, steer, correct, or override it?

Trust
How does the product communicate what the system knows, what it inferred, and where uncertainty remains?

Attention
When should an intelligent system ask for help, report progress, disappear into the background, or interrupt?

Learning
How can we validate new behaviors incrementally rather than assuming that technical capability automatically creates customer value?

AI changes what software can do. Design still determines whether those capabilities become useful products.

I tend to work across layers that are often separated:

Customer problem
      ↓
Product strategy
      ↓
Experience model
      ↓
Interaction design
      ↓
Prototype
      ↓
Working system
      ↓
Observation + learning
      ↓
Refinement

Sometimes the right artifact is a journey map or prototype.

Sometimes it is a design system.

Sometimes it is research.

And increasingly, sometimes the fastest way to understand an experience is to build enough of the real thing to use it.

That is what most of this GitHub represents.

• Making complicated systems understandable without pretending they are simple
• Designing AI around human judgment, agency, and trust
• Connecting research and product strategy to concrete interaction decisions
• Building systems that remain coherent as products and organizations scale
• Using prototypes to discover product problems, not merely demonstrate solutions
• Giving designers enough technical fluency to participate in decisions below the surface of the UI
• Creating teams where design can influence what gets built, not simply how it looks

Portfolio: donohoeux.com

Most of my finished case studies live there. GitHub is the complementary view: the experiments, systems, prototypes, and working software behind an increasingly technical design practice.