Turning a coded prototype
into a product decision engine.

The design team had a broad new concept for how agents, workflows, and apps could come together in one product. Static design files could communicate the layout, but they couldn't prove that the interaction model would work when connected to a real language model.

Elevate started as a lightweight coded prototype. It became much more: a place where designers could explore ideas in working software, researchers could test realistic experiences, engineers could evaluate implementation implications, and stakeholders could review the same interactive source of truth.

The pivotal moment came when we wired the experience to an LLM. The concept stopped feeling like a collection of screens and started behaving like a product. That fidelity enabled stronger research and user testing, which gave leadership the confidence to greenlight the redesign.

I was one of Elevate's primary maintainers. My work combined hands-on frontend development with the systems and coaching needed to help a large cross-functional group contribute safely.

• Scaled the prototype from a small design artifact into a shared product-development environment.
• Onboarded most of the product team to the repository and its AI-assisted workflows.
• Created and maintained contribution rules, review practices, reusable patterns, and project instructions.
• Reviewed hundreds of pull requests and helped contributors turn design explorations into maintainable code.
• Led and supported refactors while feature work continued in parallel.
• Built frameworks that let designers present coded variations, gather feedback, and converge on a direction.
• Demonstrated how a real code prototype could reduce ambiguity in the design-to-engineering handoff.

My hypothesis was that code could become a shared design medium rather than only the final output of engineering.

A sufficiently lightweight environment would let designers explore with the speed of a prototype while gaining the behavioral fidelity of a real application. If the same artifact could also support research, stakeholder reviews, and engineering handoff, the team could make decisions with less translation and less rework.

I made the product concept real enough to evaluate

The early side-by-side experience paired an AI conversation with a live build surface. Instead of asking participants to imagine how an AI-assisted workflow might behave, the prototype let them experience it.

That distinction mattered. Connecting the concept to an LLM exposed interaction details that static screens couldn't reveal: how instructions evolved, how generated changes appeared in context, where users needed confirmation, and how much control different audiences expected.

Research with the coded experience showed an approximately 2× improvement in NSAT among information workers and a 1.5× improvement among experienced makers and administrators. Combined with qualitative research, those results helped leadership approve the broader redesign.

I turned one prototype into a shared product model

Elevate became the central place for demonstrating how agents, workflows, and apps could coexist in one product. Teams could compare ideas in the same navigation, interaction patterns, and visual system instead of presenting disconnected concepts.

This helped the prototype become the team's source of truth and the primary place for sharing emerging designs. Over time, leadership and stakeholders began expecting new feature proposals to appear as coded clickthroughs rather than only as static design files.

I created guardrails for broad contribution

The prototype's success introduced a new problem: many contributors were new to Git workflows and production-oriented frontend practices. Designers needed guidance on when to open a pull request, how to keep files and changes small, and how to explore without destabilizing the shared experience.

I established review practices, contribution instructions, and repeatable AI-assisted workflows. The goal wasn't to turn every designer into a production engineer. It was to give people enough structure to contribute confidently while keeping the prototype coherent and reviewable.

These guardrails also made the design-to-engineering transition smoother. Engineers could inspect working behavior, reuse implementation details, and identify constraints earlier than they could from a static handoff.

I created a path from exploration to convergence

Feature toggles were initially a game changer. They let teams test competing ideas without blocking one another or forcing unfinished concepts into the default experience.

As adoption grew, the toggle system became overloaded. I created the Design Control Panel to separate short-lived design variations from durable product flags. Designers could present multiple options on a branch, gather feedback, select a winner, and remove the losing variations before returning to the main branch.

This preserved experimentation without turning every design choice into permanent configuration debt.

I connected prototyping to ongoing product improvement

The monitor and recommendations work showed that the prototype could explore more than creation flows. It could also demonstrate how a product might learn from usage and help makers improve what they had already built.

The recommendation surface connected operational signals to an actionable product change. It was well received because it made the system feel proactive without hiding the reasoning or taking control away from the maker.

As of October 25, 2026, repository and GitHub history showed:

• 1,040 merged pull requests
• 80+ GitHub contributors
• 6,360 commits across repository history
• 140 merged pull requests I authored
• 298 pull requests GitHub records me as reviewing
• 925 commits associated with my known author identities

The numbers support the larger organizational shift:

• The repository attracted contributors from design, content, research, product management, and engineering.
• Elevate became the central place for sharing designs and aligning on product behavior.
• Designers used it for both proofs of concept and real feature work.
• Researchers tested behavior that depended on real AI responses rather than scripted screens.
• Engineers received a working reference instead of translating intent from static artifacts alone.
• Leadership used the evidence from the prototype and research to approve the redesign.

The most difficult maintenance challenge was refactoring while contribution volume stayed high.

A large refactor could take several days. During that time, pull requests based on the old architecture continued to merge, which meant completed work had to be adapted again. The technical migration and the social workflow were inseparable.

I responded by encouraging smaller pull requests, clearer branch-based experiments, stronger review practices, and explicit project rules. Feature flags and the Design Control Panel reduced collisions by making work easier to isolate. The repository instructions also gave both people and AI coding tools a shared definition of acceptable implementation patterns.

The lesson was that scaling a prototype isn't only an architecture problem. It requires designing the contribution system with the same care as the product.

I would establish the hosted environment earlier.

Azure hosting eventually became a major improvement because it made the latest prototype easier to access, review, and test without local setup. Introducing that capability sooner would have reduced friction for research, stakeholder reviews, and cross-functional contributors.

I would also introduce the distinction between durable feature flags and temporary design controls earlier. The Design Control Panel solved a real scaling problem, but the team first had to experience the cost of using one mechanism for two different jobs.

Elevate demonstrates my ability to:

• Explore new design and development workflows without treating experimentation as an end in itself.
• Identify where coded experiences create unique value for design, research, product, and engineering.
• Turn an emerging practice into a repeatable system that other people can use.
• Lead through influence by teaching, reviewing, documenting, and creating useful guardrails.
• Work across disciplines to introduce new forms of collaboration with AI.
• Use prototypes not only to communicate a solution, but to produce evidence, reduce risk, and change a product decision.