72% execution. Not strategy.
Before writing a single line of code, the team talked to 30+ Product Managers across startups, scaleups, and enterprises. The pattern was the same everywhere: 72% of their time goes to execution. Sorting Slack threads, copying Figma specs by hand, writing tickets without reading the code, chasing status updates across five tools, switching context 40 times a day. Only 28% is actual strategy, the part that genuinely requires human judgment. The domain expertise and the full context have never lived in the same place.
Existing tools make the process prettier, not shorter. Linear is beautiful, Notion is flexible, but the cognitive burden stays the same. Someone still has to read the thread, check the PR, cross-reference the spec, and write the ticket. That's not a tool problem. That's synthesis work disguised as a strategic role, and it's exactly the kind of work an agent can take over entirely.
Chat was adopted. We made it proactive.
The product rests on three pillars. Full context, zero input: Lyse reads the codebase, follows Figma designs, and monitors Slack conversations without anyone having to copy-paste across tools. Tasks, not tickets: every generated task includes impacted components, acceptance criteria, and technical references, ready in seconds rather than hours. And preview before publish: nothing ships without explicit approval, so the agent generates and the team reviews in one click.
As the sole designer on the team, the interaction model was mine to define. The decision that shaped everything came from observing how PMs already work. Most of them use ChatGPT, Claude, or Copilot to draft tasks and prioritize backlogs. The chat pattern is already adopted massively. Rather than reinventing the interaction, Lyse meets users in the pattern they already trust. But a chat that waits for commands is still work for the user, so the product pushes further: the agent watches Slack, reads code changes, and initiates conversations on its own. The user shifts from commanding to validating. A fundamental design position that shaped every screen.
Iterate until it clicks. Then scale.
The first version of Lyse was a dashboard. Widgets, panels, a sidebar with filters. It looked like a PM tool because that's what the category expected. It also failed. Users opened it once, skimmed the interface, and went back to Slack. The second attempt stripped everything to a single chat input, which solved adoption but made the agent passive. It waited for commands, and most users never wrote any. The third version made the agent proactive, and early testers immediately flagged a new problem: it was too aggressive, creating duplicate tasks and misreading context. Each wrong turn narrowed what the product actually needed to be. Once the patterns stabilized, they got extracted into a component library with tokens, variants, and documentation: the Lyse Library.
That infrastructure changed the pace of everything. New screens assembled in hours, not days. Pixel-consistent from the first draft because the system already encodes the decisions. The pipeline goes from Figma spec to production component in 15 minutes, powered by Claude Code skills that enforce the design system's own rules. Craft doesn't mean going slow. It means building the infrastructure so quality becomes the default.
Standalone worked. Everywhere worked better.
Lyse started as a standalone webapp, and it worked. But user interviews and usage analytics revealed something more interesting: the value was platform-agnostic. The intelligence behind it mattered more than the interface around it. Instead of asking users to adopt a new tool, the product went to them. Slack, Teams, Google Chat, Discord. The agent now lives where teams already work, and the numbers followed: 1,500+ beta requests, 300+ active users, 10,000+ tasks generated.
Lyse was also a playground. The rare setup where every technical choice was intentional, not inherited. As CPO and only designer in a 5-person team, product vision, design system, agent architecture, and frontend were all mine to own. The agent schemas, how Lyse reasons, connects tools, and generates tasks, were designed alongside the UX, not after it. Version after version, the freedom to choose the right stack, test ideas fast, and rebuild when something didn't hold shaped everything about how the product thinks.
The AI initiates. Trust decides.
The decision to decouple value from interface was the product call that changed the trajectory entirely. 30 interviews, a clear pattern, the conviction to go where users already are instead of pulling them somewhere new. But the harder lesson was about proactive agent UX. When an AI initiates a conversation, suggests a task, or proposes a sprint plan, the entire experience lives or dies on trust. Showing the agent's reasoning, letting users correct it inline, building a feedback loop that actually improves the model. That problem is still open, and still the most interesting one to work on.
The other lesson was operational. A team of 5 (2 full-time, 3 part-time) can't afford process overhead. To maintain a real shipping rhythm, every internal workflow had to be optimized for speed and simplicity. That's why the entire stack lives in the codebase, with only two external tools: GitHub and Figma. No ticket tracker, no Slack-based decisions, no scattered documentation. Everything in one place, everything reviewable, everything shippable. That constraint turned out to be the biggest multiplier.
