TLDR¶

• Core Features: Intent-driven prototyping for enterprise UX that prioritizes conceptual models, user flows, and verifiable behaviors over static visuals and high-fidelity screens.
• Main Advantages: Faster alignment across product, design, and engineering; traceable requirements; reduced rework; clearer scope boundaries for complex enterprise workflows.
• User Experience: Teams gain clarity on system intent, edge cases, and data contracts; prototypes become executable narratives, not just attractive mockups.
• Considerations: Requires discipline, cross-functional participation, and tooling; vibe coding alone can mask gaps in logic, security, and enterprise constraints.
• Purchase Recommendation: Adopt an intent-first approach augmented by AI; use high-fidelity visuals sparingly and only after behaviors, states, and flows are validated.

Product Specifications & Ratings¶

Overall Rating: ⭐⭐⭐⭐⭐ (4.8/5.0)

Product Overview¶

Intent Prototyping presents a disciplined alternative to the increasingly common “vibe coding” movement in enterprise UX. While vibe coding—rapidly crafting visually impressive interfaces driven by intuition and generative AI—can be attractive for speed and aesthetics, it often leaves critical gaps: misunderstood domain concepts, undefined edge cases, brittle flows, and mismatched expectations between stakeholders. Yegor Gilyov’s approach reframes prototyping not as a way to make pretty pictures clickable, but as a way to capture and validate a product’s intent: what the system is supposed to do, how it behaves in different states, and how information moves through user journeys.

The core premise is straightforward: static high-fidelity mockups are too often treated as a proxy for product truth. They look complete, they demo well, and they are easy to circulate—yet they can conceal flawed assumptions. Enterprise UX rarely hinges on a button’s shade or a smooth micro-interaction; it depends on accurate conceptual models, long-running workflows, policy constraints, auditability, and clean contracts between front end and back end. Intent Prototyping addresses that reality by encoding requirements as behaviors and flows first, then layering interface design atop tested logic.

In practice, this approach supports modern development stacks and workflows. Teams can weave in tools such as React for interactive states, Supabase for rapid data modeling and policies, Deno for runtime simplicity, and Supabase Edge Functions for server-side validation and event handling. AI fits naturally in this picture—as a co-pilot for scaffolding, example generation, and refactoring—but the AI is guided by explicit intent rather than left to improvise UI states without a grounded model.

First impressions highlight three advantages. One, crisp alignment: stakeholders can see and test the intended behavior early, before design debt accumulates. Two, faster iteration: behavior-first prototypes surface missing cases quickly, enabling real correction rather than cosmetic polish. Three, stronger handoffs: engineers receive hashed-out flows, structured data contracts, and measurable criteria, reducing translation loss.

Still, Intent Prototyping is not magic. It asks teams to resist the temptation of high-fidelity-first visuals and to invest in shared language: domain entities, state machines, error handling, permissions, and performance thresholds. The payoff, however, is a prototype that functions as an executable specification. In high-stakes enterprise environments—governed by compliance, complex workflows, and multiple user roles—this shift can be the difference between a shiny demo and a deployable solution.

In-Depth Review¶

Intent Prototyping is best understood as a system for expressing product behavior in a way that is testable, traceable, and implementation-aware—without getting prematurely entangled in visual polish. The approach pivots on four pillars:

1) Conceptual Model First
Define domain entities, relationships, and lifecycle transitions before drawing screens. This model acts as the foundation for all subsequent flows and interactions. For example, in a B2B billing system, concepts like Account, Contract, Invoice, Payment Attempt, and Dispute must be explicit. Their allowed transitions—Draft to Approved, Issued to Paid, Paid to Refunded—become the product’s backbone.

2) Explicit User Flows and State Machines
Capture the path users and systems take across states, including failure modes. Instead of a single happy path, model the full state machine: loading, success, retry, partial failure, permissions denied, and timeouts. This makes invisible edge cases visible. In analytics-heavy environments, long-running operations and asynchronous updates are defined as first-class behaviors.

3) Data Contracts and Policies
Intent requires clarity about what data is read, written, and by whom. Here, tools like Supabase can rapidly prototype schema, row-level security (RLS), and RPCs. Supabase Edge Functions can validate inputs, handle webhooks, or trigger side effects. The result is a working skeleton of backend intent. The UI becomes the surface of well-understood contracts, rather than the place where product logic accidentally lives.

4) Executable Prototypes
Using frameworks like React allows teams to encode flows and states as components, hooks, and tests. Prop-driven state transitions, mocked APIs, and test harnesses turn prototypes into verifiable narratives. With Deno, developers can spin up stable, fast runtimes for edge functions or test scaffolding. The goal is not production readiness on day one but proof of behavior that’s difficult to misinterpret.

Strengths in Performance
Compared to vibe coding, Intent Prototyping is slower to impress but faster to deliver reliably. It uncovers contradictions early—say, a retention rule that conflicts with export requirements, or permission rules that prohibit a critical action. Each uncovered issue is cheaper here than when discovered after high-fidelity design and partial implementation.

AI’s Role
AI excels at fast scaffolding and pattern repetition but can easily manufacture plausible nonsense when intent is vague. In this approach, AI becomes a powerful accelerant: generating state diagrams from user stories, creating TypeScript types from schemas, proposing unit tests for edge conditions, or stubbed React flows that express transitions and error states. The difference is that AI operates within defined intent rather than leading the process with polished but shallow UIs.

Tooling Fit
– React: Ideal for representing states and transitions. Component-centric design mirrors stateful flows, making it natural to encode system intent as UI logic.
– Supabase: Rapid data modeling, authentication, RLS, and storage combine to validate assumptions about entities and permissions early.
– Supabase Edge Functions: Implement server-side actions, validation, and event handling close to the data layer, enabling realistic behavior without full backend build-out.
– Deno: Clean runtime for edge functions and scripts; pairs well with TypeScript for predictable developer experience.

Testing and Verification
Intent Prototyping encourages lightweight but useful testing early. For example:
– Contract tests: Ensure front end and back end agree on payload shapes.
– Permission tests: Validate that RLS policies block restricted reads/writes.
– State transition tests: Confirm that only valid state changes are allowed.
– Latency and timeout simulations: Stress-test optimistic updates and retries.

These tests turn prototypes into living specifications. When UI polish arrives, it sits atop a hardened behavioral foundation.

*圖片來源：Unsplash*

Where Static High-Fidelity Falls Short
Static screens are inherently snapshot-based. They struggle with deferred states (e.g., “report generation in progress”), long-running jobs, and asynchronous updates. They can obfuscate pagination logic, batching behavior, role-based visibility differences, and the impact of partial failures. Teams report false confidence because a design “looks finished.” Intent Prototyping flips that dynamic: if the flow and logic hold under test, visual polish is a safer investment.

Limitations
The method requires more upfront structure. Teams must allocate time to define models and flows; product managers, designers, and engineers must collaborate closely. It also demands discipline to resist jumping to high-fidelity visuals prematurely. However, in enterprise contexts where integrations, compliance, and multi-step workflows dominate, the structure pays for itself, reducing redesign cycles and production surprises.

Overall, the performance gains stem from reducing ambiguity and institutionalizing validation. The result is a cleaner delivery pipeline, fewer handoff misunderstandings, and prototypes that guide coding rather than distort it.

Real-World Experience¶

On enterprise teams, the most common failure pattern is a beautifully styled prototype that collapses under real data and multi-role complexity. Intent Prototyping changes the conversation from, “How does this look?” to, “What exactly happens here, and under which conditions?” When exercised on real use cases—such as procurement approvals, billing disputes, or role-based content authoring—the approach has several practical effects:

• Stakeholder Alignment
  By walking through executable flows, product owners and domain experts can confirm whether a proposed behavior respects policy, compliance, and operational constraints. For instance, in a procurement flow, an approval chain can be modeled as a state machine with conditional transitions based on spend thresholds and department policies. When a policy conflicts with a desired shortcut, the conflict emerges immediately and visibly.

• Edge Case Surfacing
  Edge cases rarely show up in a static mock unless a team creates dozens of variants. With intent-first prototypes, retry logic, timeouts, partial saves, and back-pressure behaviors can be simulated. A billing app can illustrate what happens if a payment provider responds with a soft decline, a hard decline, or a delayed webhook—before any pixel-perfect UI is created.

• Developer Confidence
  Developers benefit from clear data contracts and defined transitions. Instead of reverse-engineering logic from a Figma flow, they implement code against TypeScript types, RLS policies, and edge function signatures that already exist in the prototype. This minimizes the perennial “What did the designer mean?” friction and makes front-end state management intentional rather than ad hoc.

• Faster, Safer Iteration
  Teams can adjust behavior quickly. If a long-running export is too slow, they can implement batched processing in an edge function and update the UI to reflect queued and completed states. These changes can be user-tested in days, not weeks, because no one is repainting high-fidelity flows that assumed a synchronous world.

• AI as a Force Multiplier
  Generative tools are excellent at codifying repetitive patterns once intent is defined. For example, after defining a contract for a dispute object, AI can generate CRUD stubs, unit tests for transitions, and simple React stories in Storybook that show each state. This elevates the team to reviewing semantics rather than crafting boilerplate. However, without intent, AI tends to fill gaps with guesswork—polished, yet incorrect.

• Improved Hand-offs to Security and Compliance
  Because prototypes embody authorization rules and data access policies, security reviewers can evaluate practical enforcement earlier. RLS scripts and edge function guards provide concrete controls to test, not just promises in a spec. This matters for SOC 2, HIPAA, or internal risk frameworks, where a convincing screen is irrelevant if the policy enforcement is non-existent.

• Design Remains Essential—At the Right Time
  Intent Prototyping does not devalue design craft. Instead, it establishes the right sequence: behavior first, then visual excellence. Once flows and constraints stabilize, designers can focus on hierarchy, accessibility, visual clarity, and motion with confidence that the underlying logic is sound. High-fidelity design becomes a multiplier rather than a mirage.

• Measurable Outcomes
  In practice, teams report fewer late-stage revisions, better sprint predictability, and improved stakeholder satisfaction. Because prototypes are executable, acceptance criteria translate into tests. This reduces ambiguity during QA, and features ship with less regression risk.

Altogether, the hands-on experience reveals a simple truth: enterprise UX is an orchestration problem as much as a presentation problem. Intent Prototyping treats orchestration as the primary design artifact, and the UI becomes a natural expression of verified behaviors rather than a speculative guess dressed in high fidelity.

Pros and Cons Analysis¶

Pros:
– Surfaces domain and policy complexity early, reducing rework later
– Creates executable, testable prototypes that align design and engineering
– Integrates cleanly with modern stacks and AI-assisted development

Cons:
– Requires upfront investment in modeling and collaborative rituals
– Less visually impressive early on, which may challenge stakeholder patience
– Demands discipline to avoid reverting to static high-fidelity-first habits

Purchase Recommendation¶

If your team builds enterprise software with complex workflows, multiple roles, and compliance constraints, Intent Prototyping is an excellent fit. It shifts energy from superficial polish to verifiable behavior, helping you avoid the trap of shipping “demo-ware” that crumbles under real conditions. The method encourages collaboration among product, design, and engineering by making system intent the central artifact—expressed through state machines, data contracts, and executable flows.

Adopt an intent-first mindset, then augment it with AI and modern tooling. Use React to model states and interactions, Supabase to stand up schemas, authentication, and row-level security, and Supabase Edge Functions or Deno to implement server-side logic and long-running processes. Let AI assist with scaffolding, documentation, and test generation—but only within the guardrails of a clear conceptual model and defined flows.

For teams accustomed to high-fidelity mockups as a primary deliverable, expect a cultural shift. Early demos may look plainer, but they will tell the truth about behavior and constraints. As flows stabilize, invest in visual design with confidence. The long-term benefits—reduced ambiguity, fewer late-stage changes, stronger handoffs, and improved reliability—justify the change in sequence.

Bottom line: choose intent-driven prototyping as your default, and let visuals follow function. Vibe coding has its place for inspiration and rapid ideation, but it should not be the foundation for enterprise UX. With Intent Prototyping, your prototypes become a living specification, your team gains alignment, and your delivered product better reflects the realities of complex, high-stakes environments.

References¶

• Original Article – Source: smashingmagazine.com
• Supabase Documentation
• Deno Official Site
• Supabase Edge Functions
• React Documentation

*圖片來源：Unsplash*