Intent-Driven Development

What is it

Intent-Driven Development (IDD) is an emerging approach to building software with AI agents where:

1. The developer makes intent explicit: what should be achieved, constraints, and acceptance criteria
2. That intent is treated as a first-class artifact (not a throwaway prompt) and comes with the context the agent needs
3. AI generates the code against that intent
4. The developer reviews, verifies, and refines the result

Note: this is a recent term with no standard definition. It is used, for example, by intent-driven.dev (“making your intent explicit and structuring the context around it, so agents produce what you actually meant”) and by consultancies such as Keyhole Software. It is closely related to spec-driven development.

From code to intent

┌─────────────────────────────────────────────────────────┐
│          DEVELOPMENT EVOLUTION                          │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   1940s-50s: Machine code and assembly                  │
│   → MOV AX, 5                                           │
│                                                          │
│   Since the late 1950s: High-level languages            │
│   → int x = 5;                                          │
│                                                          │
│   2000s: Frameworks                                     │
│   → const user = await User.findById(id);               │
│                                                          │
│   2020s: Copilot/Autocomplete                           │
│   → Write beginning, AI completes                       │
│                                                          │
│   Mid-2020s: Intent-Driven Development                  │
│   → "Create endpoint to get user by ID                  │
│      with validation and error handling"                │
│   → AI generates all the code                           │
│                                                          │
└─────────────────────────────────────────────────────────┘

How it works

Traditional flow

Requirement → Design → Code line by line → Test → Deploy
    ↓
Developer writes EVERY line of code

Intent-Driven flow

Intent → AI generates code → Developer reviews → Refinement → Deploy
    ↓
Developer describes WHAT they want, not HOW to do it

Practical examples

Example 1: Creating an endpoint

INTENT:
"I need a GET /api/users/:id endpoint that:
- Validates that the ID is a valid UUID
- Looks up the user in the database
- Returns 404 if not found
- Returns the user without the password field"

AI GENERATES:

// app/api/users/[id]/route.ts (Next.js App Router)
import { z } from "zod";
import { db } from "@/lib/db";

const paramsSchema = z.object({
  id: z.string().uuid("ID must be a valid UUID"),
});

export async function GET(
  req: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  const parsed = paramsSchema.safeParse(await params);
  if (!parsed.success) {
    return Response.json({ error: "Invalid ID" }, { status: 400 });
  }
  const { id } = parsed.data;

  const user = await db.user.findUnique({
    where: { id },
    select: {
      id: true,
      email: true,
      name: true,
      createdAt: true,
      // password excluded
    },
  });

  if (!user) {
    return Response.json({ error: `User ${id} not found` }, { status: 404 });
  }

  return Response.json(user);
}

Example 2: Refactoring

INTENT:
"Refactor this component to use React Query
instead of useEffect + useState for fetching"

AI analyzes current code and generates refactored version
maintaining the same behavior but with better state management.

Abstraction levels

Level	Intent example	Complexity
Micro	“Add email validation”	Low
Function	“Create JWT authentication function”	Medium
Feature	“Implement notification system”	High
Architecture	“Migrate to microservices”	Very high

Best practices

1. Be specific with intent

❌ "Make a login"

✅ "Create a login flow with:
   - Form with email and password
   - Client-side validation with Zod
   - Call to /api/auth/login
   - Error handling with toast
   - Redirect to /dashboard on success"

2. Provide context

❌ "Add a button"

✅ "Add a 'Save changes' button to the profile
   form that:
   - Uses the existing Button component
   - Is disabled while there are no changes
   - Shows loading while saving"

3. Iterate in refinements

Initial intent → Generated code →
  "Now add tests" →
  "Improve error handling" →
  Final code

Tools supporting IDD

Tool	Strength
Claude Code	Full repository context
Cursor	Deep IDE integration
GitHub Copilot	GitHub integration

The developer role changes

BEFORE:                         AFTER:
├── Write code                  ├── Define clear intents
├── Debug syntax                ├── Review generated code
├── Search documentation        ├── Validate business logic
└── Copy/paste from Stack       └── Guide refinements
    Overflow

Current limitations

• Limited context - AI doesn’t always understand the full project
• Hallucinations - May generate incorrect code
• Security - Always requires human review
• Edge cases - May ignore boundary scenarios

Related terms

• Agentic AI - AI that executes tasks autonomously
• Repository Intelligence - AI that understands your code
• Prompt Engineering - Art of writing good intents

---

Remember: Intent-Driven Development doesn’t replace the developer—it changes their role from “writing code” to “directing and validating.” Technical knowledge remains essential for reviewing what AI generates.