How AI-assisted product design shipped two features in one session — from "this feels wrong" to merged PR
📅 February 2026⏱ One session✅ 2 PRs merged
The Starting Point
A screen that worked. And quietly failed.
The Summarizer specialist's empty state did everything right on paper. It greeted users. It offered suggestions. It explained the tool.
But something was off. The developer's own words:
"Bland and nerdy. Vast empty void, zero visual identity, greeting reads like API docs, boring pill buttons, no emotional hook."
Before
Untitled
I'm a Summarizer. Paste a URL or text and I'll give you a clear, structured summary.
[ Summarize a URL ] [ Paste text ] [ Try an example ]
Technically correct. Emotionally empty.
The Breakthrough
It wasn't a visual problem. It was a trust problem.
The first step wasn't jumping to solutions. It was finding the right question.
❌ Wrong question: "How do we make this look better?"
✅ Right question: "What is the user silently asking?"
"Will this actually be better than just using the main chat?"
That reframing changed everything about the design direction.
The Design Process
10 concepts. Interactive. In minutes.
Rather than iterating on the existing design, the session generated ten completely distinct design directions as interactive HTML mockups — not wireframes, not static images.
Each one was a real design argument. Each one was immediately evaluable as an actual interface.
Dead greeting field + missing aria-hidden — both fixed
5
PR merged
2,625 tests passing. Browser verified.
2,625
Tests passing at merge
"Looks much better."
02
The Slides Specialist
Same problem. Different tool. Harder bug.
The Slides Specialist
One visible problem. One hidden one.
Problem A — Visible
Same generic empty state the Summarizer just escaped. No visual identity. No sense of what a "deck" actually looks like.
Problem C — Hidden
The completion flow was broken.
When a deck finished generating, nothing happened. No toast. No switch to preview. User sat in chat with no idea their presentation was ready.
The hidden problem was invisible to screenshots or user testing. It was only findable one way.
How We Found It
Debugging by reading code. Not guessing.
Toast fired only for hasDualArtifact — never for slides-only (the common case)
autoSwitchToPreview setting existed in UI, in settings, in the database schema
But setProjectViewMode() was never actually called when the event fired
Two bugs. Both diagnosed from hook inspection. Before a single line was written.
The feature had been scaffolded but never completed. The setting was wired up to the UI — but the behavior it controlled didn't exist.
The Design Insight
Slides is a creative tool. Not an analysis tool.
That distinction changed the entire design direction.
State 1 — First visit
Two-column. Identity left. Style picker right — Clean Light / Dark Keynote / Warm Minimal. Choose your visual style before you type. Creative ownership from the first interaction.
State 2 — Returning user
"What are we presenting?" — Just the input, style toggles, done. Get out of the way.
"It depends where the user is in their journey with using the tool."
— The insight that led to the adaptive two-state design
State detection: does the project have any prior Slides sessions? Simple. Precise. No configuration needed.
The Methodology
5 things that made it work.
1
Generate options, then reason about them
You can't evaluate tradeoffs you haven't seen. 10 concepts before committing to one.
2
Work backwards from user behavior
"Will this be better than main chat?" is a completely different brief than "help users get started."
3
Read the code to find the real problem
Two broken behaviors found in minutes. No reproduction steps. No guessing.
4
Pipeline design and implementation
Slides design ran while Summarizer implementation was executing in subagents.
5
Code review as a feature, not a formality
Dead field + missing aria-hidden caught before merge. Not after.
Results
By the numbers.
20
Interactive HTML mockups generated
2
PRs merged to production
2,625
Tests passing at merge
2
Hidden bugs caught via code inspection
All in one session. One developer. No separate design cycles, no design reviews, no debugging sessions.
The Bigger Picture
The bottleneck was never coding speed.
It's the distance between noticing a problem and understanding it well enough to fix it correctly.