By 2027, every product team will have an AI designer

An AI Assistant for Product Design

We're building an AI design assistant that works directly on your live web application. You enter your product's URL, log in, and our AI analyzes the existing design context to help designers, PMs, and founders generate new UI components that perfectly match your current product. We don't create mockups—we ship clean, instructive code that engineers can implement immediately. This approach allows design teams and product stakeholders to iterate and prototype seamlessly within their live products.

This live editor is just the foundation. We're building toward an AI design assistant that works alongside your design team—an AI partner you'll tag in Slack, that helps with research, generates design variations, and suggests UX improvements to accelerate your workflow. We're building the assistant, not just the design tool—like having a senior designer's insights available 24/7.

The Contrarian Thesis & The Problem

Our core belief is that most "prompt-to-code" and "0-to-1" design tools are a novelty. They are compelling tools for prototyping or simple applications— but they don't address where 95% of real-world engineering and design time is spent: the process of maintaining and improving existing products that are actually delivering real-world value.

As AI continues to democratize coding with tools like Cursor, the new bottleneck isn't engineering—it's product quality. Specifically, it's the lack of access to high-quality, iterative product and design thinking. Founders and PMs are blocked by design backlogs, forced to wait for design deliverables or accept "good enough" UI generated by Claude or v0 and ship products that feel hacked together. Design is now the gatekeeper, just as coding was before.

This creates a massive opportunity. In a world where anyone can build, products will differentiate through superior product thinking and design execution. As the entire development life-cycle is disrupted by AI, the market needs a AI tool that doesn't just generate boiler plate UI, but embodies the reasoning of a world-class product designer.

Solution Vision: An AI Design Assistant

Our AI design assistant operates through two primary interfaces:

• The Live Editor: A web-based service where a user enters any URL, logs into their application, and uses an inspector-like UI to select parts of their live product. They can then prompt the AI to add new elements, modify existing ones, or revise entire sections. The AI is deeply context-aware, producing designs that are entirely consistent with the existing UX patterns and brand identity.
• The Async Agent (Slack): A user can simply @tag our AI in Slack with a request (e.g., "@AI, on the flight detail page, we need a promo banner for first-time bookers."). The agent will ask clarifying questions if needed, perform the design work asynchronously, and post back a link to the live prototype for review and further iteration.

The output is always a high-fidelity, instructive prototype. We are not trying to write perfect, production-ready code. We provide clean, well-structured HTML/CSS that makes it trivial for an engineer or a code-level AI to implement correctly, eliminating the ambiguity and rework that plagues the traditional design handoff.

The vision extends to the assistant helping validate design decisions by spinning up hundreds of synthetic users to test for UX friction, turning it into a collaborative partner that doesn't just execute tasks but helps find and solve problems.

Under the Hood: The Technical Architecture

Please note that the following represents early-stage concepts formulated by a non-engineer.

1. The Stateful Browser-as-a-Service Layer

We're solving the "edit any live app" problem through a cloud-based headless browser architecture that maintains persistent, authenticated sessions. Users interact with their actual applications through our service, which:

• Manages isolated browser instances with full cookie/session state
• Streams DOM mutations bidirectionally via WebSockets
• Bypasses CSP and iframe restrictions by operating at the browser level
• Handles complex authentication flows including 2FA

This isn't screen recording—it's a live, interactive session where we have full programmatic access to the DOM, computed styles, and application state.

2. The Design Thinking Process

The core innovation isn't just AI that generates UI—it's AI that thinks like an elite product thinker. We've reverse-engineered their mental model into a two-layer system:

Strategic Understanding (Product-Level Context)

• Market Intelligence: o3-powered research analyzes competitive landscapes and positioning
• UX Best Practices: Living RAG system of proven design patterns, constantly updated
• User Research: Deep analysis of user behaviors, pain points, and jobs-to-be-done

Tactical Execution (Task-Level Precision)

• Kontextual Style Extraction: Analyzes surrounding elements to extract design tokens
• Opinionated Design System: Next-gen component library encoding frontier design practices
• Smart Application: Knows when to follow conventions vs. innovate based on context

Every design request flows through both layers, ensuring we don't just create components—we create the right components for your product's strategic goals.

3. Productizing Design Excellence

Great designers aren't neutral—they have taste, references, and strong opinions. Different designers produce different outputs, and that's valuable. We're not eliminating this; we're productizing it.

While tools like v0 and Claude produce decent results by being opinionated (forcing Tailwind/shadcn), we're taking this insight much further. We're building a sophisticated opinion layer that sits above basic components—pre-composed UI patterns that are exhaustively annotated and LLM-optimized. Think of it as the difference between having access to ingredients versus having access to proven recipes from master chefs.

This design intelligence combines:

• Expert-designed templates for common use cases, tagged with context and rationale
• Best practices extracted from thousands of products, augmented with human commentary
• An opinionated design system that adapts to match any product's existing language

The result: AI that doesn't just generate UI, but makes the same taste-driven decisions a senior designer would make. This is the difference between acceptable and exceptional—and it's what will make our output immediately recognizable as "designed" rather than "generated."

4. The Instructive Hand-Off Principle

We deliberately don't ship production code—and that's a strategic advantage. PMs, founders, and marketers shouldn't be anywhere near production systems. For products with real users and revenue, this separation exists for good reasons.

Instead, we generate instructive prototypes: pristine HTML/CSS blueprints that show exactly what to build. We're designing for a future where engineers, supported by AI-powered IDEs like Cursor, can take our specifications and implement them perfectly in minutes. The handoff becomes trivial, but the separation remains crucial.

This focus lets us optimize for what matters:

• For designers/PMs: Move at the speed of thought without breaking anything
• For engineers: Receive clear specifications that respect your architecture
• For the product: Maintain quality, security, and consistency

Our outputs are:

• Clean, semantic HTML/CSS that serves as implementation blueprints
• Framework-agnostic markup that any engineer (or AI) can translate
• Live DOM injection for immediate visual validation
• Detailed implementation notes that respect existing patterns

By staying out of production code, we can focus entirely on design excellence and velocity. Engineers retain control over implementation quality, testing, and deployment. Everyone wins.

5. The Synthetic Feedback Loop

Engineering has always had a truth mechanism: code compiles, tests pass, metrics improve. Design has operated on opinion and faith—ship and hope. This structural blindness explains why the vast majority of digital products have bad or mediocre UX.

We're inventing design's missing feedback loop. Given generated product context and user understanding, we can synthesize hundreds of meaningful user personas and test against them in seconds. This isn't simple A/B testing—it's understanding what problem a design should solve, then measuring how effectively it solves it across diverse user models, iterating until we achieve maximum objective design effectiveness.

Today, real user testing does happen, but the truth is that it is too expensive and slow to be practical for most teams. That's why it's skipped. Synthetic testing changes the economics entirely. What costs thousands and takes weeks can happen instantly within the design process itself. This is the cornerstone of future design: Every meaningful design decision validated before it ships. Not after. The same empirical rigor that transformed software engineering, now applied to design. We're not just building a tool—we're establishing a new standard for how design works.

When this becomes as natural as running unit tests, design quality doesn't improve incrementally. It transforms. We'll be the first to make it integral to every design workflow.

6. The Network Effect Architecture

Every interaction makes our system smarter through three reinforcement loops:

Input Intelligence

When users enter their URL, we analyze their entire product—cataloging components, understanding patterns, and mapping design decisions. This feeds our reference layer with real-world context: "This promo pattern works in SaaS onboarding" or "This navigation approach handles complex hierarchies well."

Choice Signals

We always present multiple design options. Two critical signals emerge: which option users choose initially, and how they refine it. These refinements map back to specific templates and use cases, teaching our system the gap between "good enough" and "exactly right." Common refinement patterns get encoded into our opinion layer, anticipating user needs before they ask.

Validation Feedback

When our synthetic testing engine runs, we capture the delta between initial designs and optimized versions. These improvements—why certain changes increased task completion or reduced friction—become part of our design intelligence. Add real A/B test results when available, and we're building the first empirical knowledge base of what actually works in design.

This isn't just a network effect—it's a compound learning system. Each user interaction teaches our AI not just what to build, but why certain designs succeed. Unlike static design systems, our intelligence evolves with every use, getting progressively better at predicting what will work before it's even tested.

Why Now: The Confluence of Enablers

This vision was not technically feasible 18 months ago. We are at a unique moment where several key trends are converging:

• Market Priming: Tools like Cursor have conditioned the market to accept AI as a legitimate partner in the development lifecycle. The appetite and expectation for AI-native tools are rapidly growing among early adopters. PMs and Founders are already starting to use Claude or v0 to prototype UI.
• AI Maturity: LLMs have moved beyond simple text generation to complex, multi-step reasoning. Their context windows are now large enough to process the necessary visual and code context, and their "function calling" capabilities allow for the sophisticated, tool-based workflow we envision.
• Enabling Technology: The underlying tech stack is mature. Headless browsers are robust and well-supported, making our "live editing" architecture and synthetic test usage possible.

Business Model

We'll make money with B2B SaaS subscriptions ($200-500/month per month) that package the value of senior design insights—typically costing $150k/year—into a simple monthly plan.

Our pricing reflects a fundamental shift: users pay for design outcomes, not design hours. We're targeting the economic value of senior design expertise but delivering it through usage-based pricing that scales with actual value creation.

The model combines a base subscription (access + included credits) with usage tiers based on design complexity. A simple button costs pennies; a complex user flow costs dollars. Failed experiments burn minimal credits—we only capture value when we create it.

This aligns incentives perfectly. Early-stage founders can run dozens of cheap experiments to find product-market fit. Growth-stage teams can optimize entire surfaces without hiring. In both cases, they're buying velocity and optionality, not headcount.

The unit economics are compelling: we're automating away $10k+/month in design value while charging a fraction of that. As our AI improves, our margins expand while prices can actually decrease.

Our beachhead is the 500k+ PMs and founders who are currently blocked by design bottlenecks. Capturing a fraction of this initial market already represents a $100M ARR opportunity.

But the real market is much larger. Just as Cursor is making everyone an engineer, we're helping everyone access world-class design insights. As AI creates millions of new builders, the need for high-quality design will explode, and we will be the default solution. We're not just building a tool; we're building the essential design layer for the entire AI-native development stack—a $10B+ opportunity.

Competitive Landscape

The market appears crowded but we're playing a different game entirely.

Design Tools (Figma, Subframe, Tempo, Onlook, UX Pilot, etc.)

These tools will excel at net-new design creation—and they should. Figma's prompt-to-design features will be genuinely good for mockups and exploratory work. But they're constrained by their own success: serving millions of designers across every possible use case, maintaining backward compatibility, and protecting their core canvas-based model.

We're not competing for their users or their use cases. While they optimize for design creation, we optimize for product improvement. While they target designers exploring possibilities, we target PMs shipping realities. Our focus on the narrow use case of "improving live products" lets us build something they structurally won't—a tool that operates on production apps, not design files.

General AI Models (ChatGPT, Claude, etc.)

The "screenshot to Claude" approach is our most immediate competition. These models will continue to improve, and stakeholders with sufficient context can get instructive outputs from them. We don't win on context alone.

We win through obsessive focus. While general models must serve infinite use cases—from poetry to code reviews—we pour everything into one: designing improvements for live web products. This focus compounds. Every interaction teaches our system specifically about product design. Every refinement makes our next output better for this exact task. In 12 months, when a PM needs to add a component to their app, the quality and usability gap between our specialized system and Claude's generalist approach will be significant.

AI Coding Tools (Cursor, Copilot, Windsurf, etc.)

These tools face a monumental challenge: disrupting the entire software development lifecycle. They're revolutionizing how code gets written, tested, deployed, and maintained. Design is a not part of their core challenge.

Could they add design capabilities? Perhaps. But building a great design AI is a 4-10 year journey that would dilute their strategic focus while they're battling for dominance in the coding assistant space. More likely, they'll stay focused on their beachhead while we perfect ours.

The strategic dynamic here is complementary, not competitive. As they commoditize code production, design quality becomes the differentiator. Teams that can ship anything instantly will win or lose based on what they choose to ship. We're building for that future.

Our Unfair Advantage

By 2027, every product team will have AI-assisted design. The winners will be those whose AI understands products, not just UI. While others build general-purpose design tools, we're building a product improvement system that:

• Operates on your live, authenticated application
• Learns from every design decision across our network
• Understands what converts, not just what's pretty
• Ships instructive prototypes, not ambiguous mockups

The moat isn't technical—it's compound learning from thousands of real product improvements. Every competitor starting today is years behind on this data advantage.

There's even a longer-term play: as code generation becomes a commodity feature of frontier models, the strategic high ground might shift entirely to product thinking and design. Companies that deeply understand how to build great products—not just how to generate code—could own the entire product development stack. We're positioning for that possible future while solving today's immediate pain.

Conclusion

We're at the beginning of a fundamental shift in how products are designed and built. Just as AI has transformed coding, it will transform design. But unlike coding, design requires understanding context, user psychology, and business goals—not just syntax.

Kontextual Design is building the AI that understands products, not just pixels. We're creating the autonomous design partner that every product team will have by 2027.

The future of design is kontextual, intelligent, and autonomous. We're building it.