Intent-Driven Development

What is it

Intent-Driven Development (IDD) is an emerging paradigm where:

1. The developer describes what they want (the intent)
2. AI generates the code that fulfills that intent
3. The developer reviews and refines the result

It’s the natural evolution of AI-assisted programming.

Pronunciation

IPA: /ɪnˈtent ˈdrɪvən dɪˈveləpmənt/

Sounds like: “in-TENT DRIV-en di-VEL-op-ment”

From code to intent

┌─────────────────────────────────────────────────────────┐
│          DEVELOPMENT EVOLUTION                          │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   1960s: Machine language                               │
│   → MOV AX, 5                                           │
│                                                          │
│   1980s: High-level languages                           │
│   → int x = 5;                                          │
│                                                          │
│   2000s: Frameworks                                     │
│   → const user = await User.findById(id);               │
│                                                          │
│   2020s: Copilot/Autocomplete                           │
│   → Write beginning, AI completes                       │
│                                                          │
│   2026: 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:

// routes/users.ts
import { z } from "zod";
import { db } from "@/lib/db";
import { NotFoundError } from "@/lib/errors";

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

export async function GET(req: Request, { params }) {
  const { id } = paramsSchema.parse(params);

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

  if (!user) {
    throw new NotFoundError(`User ${id} not found`);
  }

  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 Chat	GitHub integration
Cody (Sourcegraph)	Semantic code search

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.