Select Page
2025 – Present
AI-Enabled Product Design at FRONTSTEPS

Overview.

Over the past few years, AI has become part of nearly every conversation around product development. As Design Lead, I helped lead the evolution of our design practice, introducing new ways of working that embraced these emerging capabilities.

Working closely with product managers, engineers, and our AI-focused engineering lead, I introduced shared workflows, systems, and AI-assisted practices that improved product understanding, customer research, design systems, and the experiences we ultimately shipped. As the tools evolved, that work expanded into implementation, allowing me to develop and contribute production code directly within our engineering workflow.

Role

Lead Product Designer

Industries

Enterprise Saas
HOA & Property Management

Products

Resident Experience
Community Management
Back-office Operations
Security & Access

Team

Design (2)
Product Team (8)
Engineering Team (~30)

Rather than focusing on a single project, this page explores how AI changed the way I understand, design, and build products.

How we integrated AI.

Instead of introducing AI in one place, we looked for opportunities to strengthen how we understood, designed, and built products.

Product understanding.

Challenge

One of the biggest challenges in enterprise software isn’t designing the solution—it’s understanding the product deeply enough to design the right solution.

Product documentation, engineering conversations, legacy workflows, business requirements, support history, research findings, screenshots, and competitive analysis all contained valuable context, but they rarely lived in one place.

My approach

Rather than treating AI as another design tool, I used it to capture and preserve product understanding throughout the design process.

By bringing documentation, research, business context, and design thinking together in one place, I could spend less time rebuilding context and more time solving the problem.

Evolution

As AI capabilities evolved, so did the way I built product understanding. I shifted from asking individual questions to building an environment where AI served as a historian of the product—preserving the details, decisions, and context so I could focus on solving the right problems.

Started Here

Assistant

Knows

Current Conversation

Conversation History

“Rewrite this.”

“Summarize this.”

“Brainstorm ideas.”

Today

Partner

Can Reference

Product Documentation

PRDs

Legacy Workflows

Screenshots

Customer Research

Business Goals

My Thinking

“Which approach feels stronger?”

“What trade-offs am I overlooking?”

“Would another pattern work better?”

Today

Teammate

Stays Connected To

Connected Documentation

Customer Research

Support Insights

Product Roadmap

Design System

Engineering Changes

Continuously Updated Product Knowledge

“What’s changed?”

“What should we revisit?”

Outcomes

Faster onboarding to complex products
Shared product understanding
Better-informed design decisions
Less time rebuilding context

Research.

Challenge

Customer feedback existed everywhere, but it was fragmented across teams and tools.

Support, Sales, Product, and UX all developed different perspectives on what mattered most because each team interacted with customers in different ways. I wanted a way to bring those perspectives together into a single, evolving understanding of our users.

My approach

Rather than treating research as a series of individual studies, I worked to build a shared source of customer understanding.

By bringing together support conversations, sales calls, product demos, formal research, surveys, analytics, and roadmap feedback into a single searchable repository, we could move beyond individual opinions and explore what our customers were consistently telling us.

Instead of asking, “Who do we believe?” we could ask, “What does the evidence say?”

A new way of working

Research lived in reports
Customer understanding became continuously accessible.
Teams relied on memory
Teams explored evidence together.
Research questions became follow-up tasks
Questions could be answered during the meeting.
Decisions were shaped by individual perspectives
Decisions became grounded in customer evidence.

Questions we could answer

"What are the biggest pain points across our customer base?"

"What evidence supports this roadmap initiative?"

"Can you surface quotes from customers struggling with this workflow?"

"How do support conversations compare with our interview findings?"

"Has customer sentiment changed since we last worked on this feature?"

"Which problems consistently appear across support, sales, and UX research?"

Example

Resident Login AI Assistant Strategy

Resident login consistently surfaced as one of our largest sources of support requests. Our initial assumption was that residents were simply forgetting usernames and passwords.

Looking across support conversations, customer interviews, sales calls, and product demos revealed a different story. Login wasn’t the real problem. Residents were struggling to understand how their community worked digitally—which portal to use, what they could do there, and how to complete common tasks.

That shifted our strategy from improving authentication to improving guidance.

Rather than building a better login flow, we explored an AI assistant grounded in each community’s documents, rules, and processes. Instead of simply helping residents get into the platform, it could guide them from their first question through task completion while reducing support requests for both residents and property management teams.

The problem wasn’t helping residents log in—it was helping them accomplish what they came to do.

Outcomes

Shared customer understanding
Evidence-driven roadmap discussions
Real-time research synthesis
More objective product decisions

Implementation.

Challenge

Even with a stronger design system, there was still a gap between designing an experience and seeing it implemented in the product.

Handoff meant translating design intent into engineering requirements, reviewing the result, and working back through details that often became clearer once the design was running in the actual product.

My approach

I began using Claude Code directly in our source code to carry design work further into implementation.

I can now develop UI changes in the actual product, work through technical constraints as they surface, test and refine the experience in context, and push completed code for engineering review.

Tooling

Claude Code

Figma

Git

Design System

Evolution

This changed more than the speed of implementation. It changed where design could participate in the development process.

Instead of treating the design as finished at handoff, I can continue making design decisions in the product itself. Engineering still owns technical review and approval, but we can start that conversation around working code rather than a static specification.

A new way of working

Design stopped at handoff
Design continued into implementation.
Technical constraints surfaced downstream
I could respond to constraints while building.
Engineering translated static designs
Engineering reviewed working implementations.
Design drift was found after the fact
I could identify and correct it in the codebase.

Outcomes

Design intent carried further
Faster design-to-code iteration
Earlier technical feedback
More consistent implementations

Design systems.

Challenge

Traditional design systems help designers and engineers build consistent products. As AI became part of our workflow, I realized our documentation also needed to support the tools our teams were beginning to use.

Without clear standards, AI-generated interfaces were inconsistent and often required significant refinement before they could be used.

My approach

Before changing our documentation, I partnered closely with engineering to understand how our components were actually built—from tokens and naming conventions to implementation patterns and technical constraints.

Using those insights, I redesigned our design system around a single goal: helping both people and AI understand not just what to build, but how and why components were used.

Tooling

Figma

Claude Design

Markdown

Design Tokens

Building an AI-native design system

Usage guidance

Human-readable and AI-readable documentation.

Component API

Explicit variants and properties that AI can reliably reference.

Implementation guidance

Design intent alongside engineering considerations.

Design tokens

Shared language between design and engineering.

Outcomes

A shared design language
More consistent implementations
Higher quality AI-generated prototypes
Less time refining generated work

Working together.

Challenge

AI quickly became part of everyone’s workflow, but everyone was using it differently. Designers, product managers, and engineers were each developing their own habits, making it difficult to share context, build consistently, and learn from one another.

My approach.

Rather than treating AI as an individual productivity tool, I worked to make it part of our team’s shared workflow.

By documenting processes, building common resources, collaborating closely with engineering, and encouraging experimentation across disciplines, we established a more consistent way of working that everyone could build upon.

How we worked together

Research had to be rediscovered
Research was instantly accessible.
Product knowledge depended on memory
Product knowledge became searchable.
Prototypes started from blank canvases
Prototypes started from shared systems.
Design and engineering exchanged handoffs
Design and engineering worked from shared implementations.

What changed

The biggest shift wasn’t that everyone started using AI. It was that everyone started from the same foundation. Product managers, designers, and engineers could build on shared product understanding, customer research, design systems, and implementation guidance instead of independently gathering information before every project.

That changed where we spent our time and how far design could carry the work. Instead of rebuilding context or stopping at handoff, we could focus on evaluating ideas, refining experiences, validating decisions, and working together on real implementations with greater context and confidence.

Stronger cross-functional collaboration
Shared AI workflows
More consistent product decisions
A more scalable design practice

Let's Chat