TLDR¶

• Core Features: Intent-driven prototyping for enterprise UX, contrasting static high-fidelity mockups and AI-powered “vibe coding” with structured, model-first design.

• Main Advantages: Clarifies conceptual models and user flows, accelerates iteration, reduces design debt, and bridges teams with shared artifacts aligned to business goals.

• User Experience: More predictable outcomes, tighter feedback loops between design and engineering, and prototypes that validate real behavior beyond surface-level aesthetics.

• Considerations: Requires discipline, domain modeling effort, and governance; AI-generated flows risk incoherence without guardrails and strong information architecture.

• Purchase Recommendation: Invest in intent prototyping if you manage complex enterprise workflows; avoid pure vibe coding without structure; pair AI with explicit intent maps.

Product Specifications & Ratings¶

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

Product Overview¶

Intent Prototyping is a disciplined approach to building prototypes that foregrounds the underlying conceptual model and end-to-end user flows, rather than styling or pixel fidelity. In enterprise UX—where the stakes involve compliance, multi-actor workflows, and complex data relationships—teams often lean on static high-fidelity mockups to rally stakeholders. These mockups, while visually persuasive, commonly mask the absence of a coherent system model: objects, states, permissions, and transition logic remain thin or ambiguous. As a result, implementation teams inherit uncertainty, product decisions get deferred to sprint zero, and the final experience drifts from original goals.

The article by Yegor Gilyov critiques this pattern and examines whether AI-powered prototyping can fill the gap. The recent wave of “vibe coding”—rapidly generating code and interfaces with AI on the fly—has undeniable appeal. It creates interactive artifacts fast, encourages exploration, and gives stakeholders something tangible to click through. But it also introduces risk: without a structured representation of intent, these prototypes can be coherent at the surface and chaotic underneath. They may validate “look and feel” while missing key dependencies, access rules, error states, and cross-journey continuity.

Intent Prototyping reframes the process around explicit articulation of goals and constraints. It challenges teams to define the semantic backbone—entities, relationships, actions, policies, and flow checkpoints—before AI or front-end tooling fills in components. The technique is not anti-AI; rather, it positions AI as a powerful engine once fed clear intent, domain language, and guardrails. You can still move fast, but you encode the why and how before generating the what.

First impressions: the method is refreshingly pragmatic. It respects enterprise realities: multiple personas, brittle integrations, long-lived data, and non-negotiable audit trails. It encourages teams to replace static mockup sign-offs with living prototypes that carry traceable intent across design and development. And it suggests a healthy middle path between design theater and code-by-vibes: an approach that leverages AI for speed while resisting the temptation to let it define the product’s logic.

In-Depth Review¶

Enterprise UX has long struggled with fidelity mismatch. A glossy mockup can appear “done,” yet fundamental questions remain unanswered. What objects exist? How do they change state? What happens if a downstream dependency fails? Who can see or edit what? Where do exceptions route? The friction emerges in implementation when these choices can no longer be deferred. By then, cost-of-change has spiked.

Intent Prototyping addresses this through a layered approach:
– Conceptual model first: Identify core entities, their relationships, lifecycle states, and constraints.
– Task and flow mapping: Define entry points, transitions, decisions, and outcomes across personas.
– Policy and permission design: Encode role-based access, auditability, and data governance early.
– Interface scaffolding: Generate or compose UI once semantics are established; render realistic states, not just happy paths.
– Validation via working behavior: Use prototypes to test flows, edge cases, and data interactions—not just visual consistency.

AI’s role in this framework is catalytic but bounded. AI can generate scaffolding—screens, functional shells, state handlers, and placeholder integrations—once the intent metadata exists. Conversely, if you start with AI generation without intent, you’ll likely create prototypes that feel right but behave wrong. This is the heart of the critique of pure vibe coding: it optimizes for immediacy and aesthetic coherence instead of systemic truth.

Performance in practice
– Speed: With intent captured as structured artifacts (e.g., entity schemas, state machines, flow maps), AI can rapidly produce consistent UI and logic templates. Iteration time shrinks from days to hours.
– Consistency: Centralized intent ensures that changes to a policy or entity state cascade through generated artifacts, reducing drift.
– Coverage: Explicit modeling forces teams to identify error states and off-happy-path scenarios. Prototypes become more realistic as a result.
– Traceability: Decisions live near the model, not in scattered comments or slide decks. This reduces design-debt and eases handoff.

Specifications orientation
– Conceptual entities: Name, attributes, relationships, lifecycles.
– Flow specifications: Persona, triggers, preconditions, steps, decision nodes, outcomes.
– Policy schemas: Roles, permissions, governance rules, audit events.
– UI contracts: Components aligned to entity states and transitions.
– Validation rules: Constraints, error handling, recovery paths.

Comparison: high-fidelity static mockups vs. intent-driven prototyping
– Static mockups excel at communication but under-specify behavior. They create sign-off momentum without covering systemic complexity.
– Intent prototyping preserves communication while grounding it in executable logic. It augments fidelity with semantics.

AI-powered vibe coding vs. intent-driven AI usage
– Vibe coding: Generate UI/logic together, guided by prompts and taste. Risks: incoherent flows, weak error handling, brittle permissions, poor maintainability.
– Intent-driven AI: Feed AI with an explicit model and flow, generate consistent artifacts, continuously validate behavior. Gains: alignment, reliability, and faster convergence.

*圖片來源：Unsplash*

Toolchain considerations
While not prescriptive about specific stacks, the approach integrates well with modern tooling:
– React for component-driven UI that maps cleanly to entity states and transitions.
– Edge functions on platforms like Supabase for secure, event-driven server logic and integration points.
– Deno-based runtimes for fast, portable development with TypeScript-first ergonomics.
– PostgREST-like patterns (e.g., Supabase) for well-defined data contracts tied to entity models.

The article’s central claim is not that AI is the solution, but that AI becomes a sensible accelerator once a team has done the intent work. Treat the model as the source of truth, the flows as the verification mechanism, and AI as the generator of consistent, testable experiences.

Risks and caveats
– Over-modeling: Teams can stall by perfecting models instead of shipping. The cure is to tie modeling to scenario-driven prototypes that are exercised weekly.
– Governance fatigue: Permissions and auditability are essential in enterprise contexts; they must be pragmatic, not exhaustive from day one.
– Stakeholder habituation: Some stakeholders equate fidelity with readiness. Teams must re-educate to value behavioral fidelity over pixel polish early on.

Evidence of effectiveness
– Shorter rework cycles: Behavioral defects are caught earlier when prototypes carry real states and transitions.
– Improved cross-functional alignment: PMs, designers, and engineers share a single artifact that is both readable and executable.
– Better onboarding: New team members can explore the system by running realistic flows rather than parsing static decks.

Real-World Experience¶

Consider a complex B2B platform with multi-role access: admins configure policies, managers approve transactions, and operators execute tasks. In a traditional mockup-first process, the team might produce immaculate screens showing lists, detail views, and approval modals. Yet crucial questions remain unmodeled: what happens when an approval times out? Can managers edit operator inputs post-submission? How are exceptions escalated across time zones? When the build starts, these questions force late-stage changes to architecture, data, and permissions.

With Intent Prototyping, the team first defines entities (Transaction, Policy, Approval, Exception), their states (draft, pending, approved, rejected, expired), and the transitions that move them. They outline flows per persona: an operator creates a draft; a manager receives a time-bound approval task; exceptions generate an escalation event. They specify roles—operator, manager, admin—and attach permissions and audit events to each transition.

At this point, AI tools can be prompted with the explicit model:
– Generate React components that reflect entity states (e.g., different UI for pending vs. expired approvals).
– Scaffold Supabase Edge Functions to handle transition logic and log audit events.
– Produce test fixtures simulating timeouts and escalations.
– Draft validation messages and error handling for off-happy-path outcomes.

The prototype is now more than clickable: it behaves close to production during critical flows. Stakeholders can trigger expirations, simulate role changes, and observe audit logs. Feedback shifts from “this button should be rounder” to “should expired approvals remain editable by managers?” Design discussions become about policy intent and user safety, not superficial visual preferences.

In another scenario—data-heavy analytics dashboards—vibe coding can rapidly assemble charts that look credible but misrepresent data lineage and permissions. Intent Prototyping requires that the data model specify provenance, freshness, and role-based access. AI can then generate charts that gray out restricted data and expose explicit freshness indicators. The prototype highlights integrity and compliance attributes, not just visual impact.

Teams report smoother handoffs: engineers rely on entity and flow specs rather than inferring behavior from pixels. QA gains clearer test plans aligned to state machines and policies, covering not only happy paths but also error states and escalations. PMs can track scope through intent coverage (which states and flows are implemented) rather than counting screens. This reduces the classic gap between design promise and production reality.

The approach also fosters resilience. When regulatory requirements shift, updating the policy schema and state transitions lets AI regenerate affected screens and handlers. Instead of hunting through ad hoc code and detached mockups, teams modify the source of truth and watch artifacts align. Over time, this creates a durable product backbone that accommodates change without breaking the experience.

The user experience improves because the prototype early on captures what users need to do, not just what they see. Operators encounter sensible defaults and predictable outcomes, managers get clear exceptions, and admins see coherent audit trails. This is the difference between UI that looks right and a system that behaves right. In enterprise contexts, behavior wins.

Pros and Cons Analysis¶

Pros:
– Elevates behavioral fidelity over cosmetic polish, reducing late-stage surprises.
– Uses AI as an accelerator within guardrails, improving speed without sacrificing coherence.
– Aligns teams around shared, executable intent artifacts, simplifying handoffs and QA.

Cons:
– Requires up-front modeling discipline that some teams may resist.
– Risk of over-engineering models if not tied to scenario-driven validation.
– Stakeholders accustomed to static mockups may need retraining on new validation methods.

Purchase Recommendation¶

If your organization builds complex, multi-role enterprise applications, Intent Prototyping is a strong recommendation. It reframes prototyping from “make it look real” to “make it behave real,” which is where most delivery risks lie. By anchoring prototypes in explicit conceptual models, flows, and policies, you reduce ambiguity, accelerate development, and catch defects earlier. This approach also makes AI genuinely useful: instead of asking AI to invent structure, you provide structure and let it generate consistent UI and logic around it.

Avoid relying on pure vibe coding for anything beyond exploratory spikes. While vibe coding can spark ideas and quickly visualize possibilities, it often glosses over the constraints that define enterprise success: permissions, auditability, error handling, edge-case paths, and data lineage. Without an intent backbone, AI-generated prototypes may be impressive demos that collapse under real-world requirements.

For teams ready to adopt this approach, start small:
– Choose a critical flow with at least one non-happy path.
– Model entities, states, and policies minimally but explicitly.
– Use AI to generate UI scaffolds and server functions tied to the model.
– Validate weekly with stakeholders by exercising realistic scenarios, including errors and escalations.
– Iterate your intent artifacts as a first-class product asset.

Bottom line: Intent Prototyping delivers superior reliability, clearer communication, and faster convergence on the right product. It transforms AI from a novelty into a disciplined accelerant. For enterprise UX teams, it offers a practical, scalable way to reduce design theater, increase behavioral truth, and ship with confidence.

References¶

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

*圖片來源：Unsplash*