Prompts. Context. Now: intent.

Intent-Driven Development

Each step made AI output more reliable. Intent is the next one — structured files that give agents explicit contracts to build against instead of ambiguity to guess through. Fewer hallucinations. Predictable output.

Get the prompt Why intent?

GitHub Gemini CLI

weather.aim

---
aim: weather
facet: intent
---

# Weather

## Summary
Current conditions widget.

## Requirements
- Show temperature and location.
- Refresh every 10 minutes.

## Contract: Fetch

### Ensures
- Returns current data.
- Fails gracefully when offline.

Why intent?

Every generation of AI tooling reduced the gap between what you mean and what the AI builds. Intent closes it.

Era 1 — Prompt

"Build me a password reset flow."

AI fills in the blanks. Behavior varies with model, phrasing, and temperature. Hallucinations creep in wherever the spec is silent.

→

Era 2 — Context

"Here are my requirements doc, schema, and existing code. Now build the reset flow."

AI infers from context. More consistent — but it still interprets. Different runs produce different results. No way to verify alignment.

→

Era 3 — Intent

## Contract: Reset

### Ensures
- Reset link is sent.
- Single-use is enforced.

AI verifies against a contract. Explicit invariants leave no room to guess. Same spec → same output across agents, models, and sessions.

Inference vs. contract

When AI has no contract, it guesses what "correct" means. A .aim file defines it — so the agent can verify its own output.

AI infers — no contract

"Users reset their password by email. The link should expire. Tokens are single-use. Log resets for auditing..."

AI decides what "correct" means. Every run interprets the spec differently. No way to verify alignment after the fact.

AI verifies — explicit contract

---
aim: auth.reset
facet: intent
---

# PasswordReset

## Summary
Email-based reset flow.

## Requirements
- Token expires after 24h.
- Single-use only.
- Log all resets.

## Contract: Reset

### Ensures
- Reset link is sent.
- Single-use is enforced.

"Correct" is defined. AI checks its output against the contract. Same spec → same behavior across every agent and session.

Get started in 3 steps

Each step uses one specialized agent. Paste the prompt into Claude, Cursor, Copilot, or any chat-based assistant and follow its guidance. No new tools required.

@aim-architect Start here

Describe your feature, get a structured spec

Tell the Architect agent what you want to build in plain English — the actors, rules, and edge cases. It asks clarifying questions, then generates one or more .aim files and saves them to your repo. These files are the contract everything else builds from.

@aim-developer

Point the Developer at your intent files

The Developer reads the .aim files and generates production-ready code and tests. Working from an explicit contract — not a vague prompt — it knows what to build, what the edge cases are, and what "done" looks like. Also handles code fixes when drift is reported.

@aim-reviewer

Review alignment before you merge

Run the Reviewer to compare your implementation against the intent. It produces a drift report and assigns each finding: code fix (back to the Developer) or intent revision (back to the Architect). Repair is explicit — never silently normalized.

Shortcut: Pull a ready-made package from the registry and skip straight to step 2. Great for seeing the full loop before authoring your own intent. Try a registry package →

Copy a prompt to get started

Paste any of these into your AI coding assistant. Start with the Architect — it will ask you about your feature and create the .aim files.

Architect Start here

Turns your plain-English description into structured .aim files. Use this first for any new feature or component.

Developer

Generates code and tests from your .aim files. Also handles code-side fixes when the Reviewer reports drift.

Reviewer

Checks that your code matches the intent and produces a drift report. Assigns each finding to the Developer (code fix) or Architect (intent revision).

Gemini CLI Extension

Skip the copy-paste entirely

AIM is a first-class extension for Gemini CLI. Instead of copying prompts into a chat window, invoke specialized personas directly from your terminal.

Zero-prompt integration

The extension bundles the Intent-Code Consistency skill, letting Gemini automatically suggest AIM when it detects hallucinations or logic drift in your project.

✓ Native personas — @aim-architect, @aim-developer, @aim-reviewer
✓ Auto-discovery — Gemini suggests AIM when it detects drift or hallucinations
✓ Local linking — gemini extensions link . for project-scoped use

View on Gemini CLI →

Terminal

# Install the AIM extension
gemini extensions install \
  application-intent-model

# Invoke personas directly
gemini "@aim-architect I want to \
  build a 2FA flow"

gemini "@aim-developer \
  build weather in React"

gemini "@aim-reviewer \
  review auth for drift"

Or pull a ready-made package

Don't want to write a spec from scratch? Pull a pre-built package from the registry and have it built in your stack with one prompt.

Start with a working example

The weather package has schema, flow, contract, and view all defined. Fetch it and build it in React, Vue, or plain JS — in a single prompt. No authoring needed to see the full loop in action.

weather game.snake terminal.countdown game.tango

Browse Registry

Agent prompt — weather package

# Paste into Claude, Cursor, or Copilot

Initialize as an AIM v3.1
Developer Agent by reading:
intentmodel.dev/brain.developer.md
intentmodel.dev/spec.md

Command: build weather in React.

Execute the full protocol:
1. Fetch the package into
   ./aim/ via sinth fetch.
2. Generate production-ready
   code and tests.