The Missing Layer In AI-Driven Software Development: Intent

In the race to build faster with AI, teams are overlooking a fundamental gap in their software stack. On one side, tools like Dovetail and Intercom capture user signals—what users need. On the other, platforms like Cursor and v0 turn instructions into working code. But the middle layer, where teams decide what gets built and why, is missing entirely.

This missing segment isn’t just empty space; it’s the difference between solving the right problem and solving the wrong one. Most organizations skip it, feeding raw feedback directly into AI agents. The result? Code that may work technically but fails to address the actual user friction.

We call this missing layer the Intent Layer—a structured system that translates user signals into clear, executable specifications.

Prompts Are Not Intent

A prompt is a temporary request—often vague and ephemeral—while intent is a precise, auditable specification. Consider the difference:

| Prompt | Intent Specification | |------------|--------------------------| | "Add a checkout flow" | Preconditions, success criteria, edge cases, and traceability to user friction | | Ephemeral—typed once and discarded | Versioned, auditable, and persistent | | Invented by the developer on the spot | Derived from user research and data | | Optimized for speed | Optimized for correctness |

When a developer opens Cursor, they shouldn’t have to invent context from scratch. The Intent Layer should already define what needs to be built and why, allowing the agent to execute against a verified specification.

Prompts generate code. Intent specs generate the right code.

The Three Layers of Intent

Modern software development is converging toward a three-tier architecture:

1. Intention: The Raw Signal

This is the unstructured data where user friction first appears—interview transcripts, support tickets, analytics dashboards, and NPS survey responses. These signals are scattered across silos, making it difficult to identify patterns or prioritize work. The raw signal is the evidence of where your product fails its users.

2. Structure: The Intent Layer

This is the computational core that transforms abstract friction into a formalized specification. It doesn’t ask developers or product managers to write specs from scratch; instead, it derives them from data.

An IntentSpec is a machine-readable contract, not a document. It includes:

• Objective: A clear statement of the problem to solve, e.g., "Reduce cart abandonment at payment step."
• Success Criteria: Measurable outcomes like "Checkout completes in under 3 seconds on 3G" and "Cart abandonment drops from 23% to below 15%."
• Constraints: Technical or business rules, such as "Must work without JavaScript enabled."
• Outcomes: Verifiable metrics, e.g., "Conversion rate increase at payment step."
• Edge Cases: Predefined scenarios like "Payment declined → show retry with alternative method."

This specification is both executable by AI agents and reviewable by humans. It eliminates guesswork and ensures alignment across teams.

3. Projection: Execution

This is where AI tools like Cursor, Claude Code, and v0 operate. When these agents receive an IntentSpec instead of a vague prompt, they execute against explicit criteria. There’s no ambiguity, no hallucination—just code that meets the defined standard.

Why This Gap Exists

Today, intent is fragmented across tools and teams:

• Research data lives in Dovetail.
• Specifications are stored in Notion or Google Docs.
• Tasks are tracked in Jira or Linear.
• Critical context often exists only in someone’s head.

Each handoff introduces drift. Each interpretation introduces error. No single system synthesizes user friction into structured, machine-readable intent. The fix isn’t adding another tool—it’s building a layer that sits above existing systems, consolidating signals into actionable specifications.

The AI Execution Trap

AI has made prototyping instantaneous, but this speed creates a dangerous illusion. Teams skip the hard work of defining what they’re building because they can ship something quickly. A polished AI-generated feature might launch in a day, only to increase user drop-off because no one validated the underlying intent.

This phenomenon, sometimes called The Vibe Coding Hangover, highlights the risk of prioritizing execution over clarity. When context is distributed across multiple stakeholders—product managers, designers, and AI agents—prompts become requests without a shared definition of success. The bottleneck has shifted from writing code to defining what code to write.

The Evolving Role of Product Managers

Product managers have traditionally acted as translators: gathering user insights, synthesizing problems, and writing specifications for engineers. But language models excel at compression—they can take a well-formed problem and produce working code. As a result, the product manager’s role is shifting from writing handoff documents to forming intent clearly enough that agents can act on it directly.

This shift isn’t a demotion. Clarity is harder than verbosity. Precision is harder than prose. The best product managers will become architects of intent, ensuring that every AI-generated output aligns with real user needs.

What an Intent Layer Delivers

• Captures friction from real user signals—not intuition alone—by consolidating support tickets, research, and analytics into a single source of truth.
• Structures intent into versioned, machine-readable specifications with explicit success criteria, constraints, and edge cases.
• Feeds agents exactly what they need to execute, eliminating hallucinations and reducing drift between teams.
• Verifies outcomes against the defined spec after shipping, confirming whether the user friction actually decreased.
• Preserves memory so teams understand why something was built, not just that it was built.

Who Owns Intent?

The responsibility for Intent Layer spans roles. Product managers define the problem, designers validate user needs, engineers ensure feasibility, and data teams measure outcomes. But ownership isn’t about control—it’s about collaboration. The Intent Layer serves as the single source of truth, ensuring alignment across all stakeholders.

As AI accelerates execution, the teams that thrive will be those that master the layer in between: the Intent Layer. It’s not just the missing piece of the stack—it’s the future of how software gets built.