Skip to content
Casulo AI Labs AID AI Integrated Development
AID v2.3.0 is out.See what's new →

Overview

AID — AI Integrated Development — is a methodology and toolchain for building software with AI coding agents. A structured, human-gated pipeline carries a work item from first understanding all the way to delivered code, without the ad-hoc drift of unstructured AI assistance. “Integrated” is the point: the human and the AI co-execute every phase — the AI proposes, the human steers, and nothing advances without an explicit OK.

These docs are the reference for both the methodology and the tool that ships it. If you are new, read on; the sections are ordered the way you will actually use AID.

The pipeline at a glance

Section titled “The pipeline at a glance”

Every work item moves through the same phases. Each produces a reviewable artifact and ends at a human gate — you approve before the next phase begins. The flow starts at configuration and ends at delivered, optionally monitored, code.

flowchart TB
    classDef prep    fill:#1E3A8A,stroke:#1E3A8A,color:#ffffff
    classDef def     fill:#6D28D9,stroke:#6D28D9,color:#ffffff
    classDef map     fill:#0F766E,stroke:#0F766E,color:#ffffff
    classDef exe     fill:#166534,stroke:#166534,color:#ffffff
    classDef delopt  fill:#C2410C,stroke:#C2410C,color:#ffffff,stroke-dasharray:5 4
    classDef aux     fill:#E5E7EB,stroke:#9CA3AF,color:#1F2937,stroke-dasharray:4 3
    classDef offpipe fill:#374151,stroke:#374151,color:#ffffff,stroke-dasharray:6 4
    classDef entry   fill:#B45309,stroke:#B45309,color:#ffffff

    subgraph G0[" 0 · Choose your entry "]
        SC["/aid-&lt;verb&gt;[-&lt;artifact&gt;]<br/>shortcut · I know my change"]:::entry
        TR["/aid-triage<br/>not sure? suggest-only"]:::entry
    end
    subgraph GS[" Support "]
        Init["aid-config<br/>setup · once"]:::aux
    end
    subgraph G1[" Knowledge Base Maintenance "]
        Disc["1 · aid-discover<br/>brownfield"]:::prep
        Sum["aid-summarize<br/>optional"]:::aux
        HK["aid-housekeep<br/>on-demand · off-pipeline<br/>KB-DELTA · SUMMARY-DELTA · CLEANUP"]:::offpipe
    end
    subgraph G2[" Definition "]
        Desc["2a · /aid-describe<br/>broad / new project"]:::def
        Def["2b · aid-define<br/>decompose features"]:::def
        Spec["3 · aid-specify<br/>full path"]:::def
        Plan["4 · aid-plan<br/>full path"]:::map
        Det["5 · aid-detail<br/>full path"]:::map
    end
    subgraph G4[" Execution "]
        Exe["6 · aid-execute<br/>8 task types · graded loop"]:::exe
    end

    Eng["Shortcut engine<br/>INTAKE→CAPTURE→SPEC→PLAN→DETAIL→GATE<br/>collapsed Describe→Detail · autonomous"]:::def
    Dep["aid-deploy<br/>shortcut path"]:::delopt
    Mon["aid-monitor<br/>shortcut path"]:::delopt

    TR -. suggests .-> SC
    TR -. suggests .-> Desc
    Init --> Disc --> Desc
    SC --> Eng --> Exe
    Desc --> Def --> Spec --> Plan --> Det --> Exe
    Exe -. "on demand" .-> Dep
    Exe -. "on demand" .-> Mon
    Exe -. "when finished" .-> HK
    HK  -. "targeted KB refresh" .-> Disc
    Mon -. "bug → /aid-fix" .-> SC
    Mon -. "change request" .-> TR

Three entry points (plus /aid-ask for a plain question) · 92 skills — 14 classic pipeline/on-demand skills, the /aid-triage router, /aid-ask (a Q&A alias of /aid-query-kb), and 76 verb-first shortcut skills. Name your change with a shortcut and the shortcut engine collapses Describe through Detail into one autonomous run straight to Execute; ask /aid-triage when you’re not sure which fits; or run /aid-describe for broad or new-project work through the full six-phase pipeline.

The six core phases, in order (full path):

  1. Discover — map an existing codebase into a Knowledge Base the agents can reason over. (Brownfield only; greenfield starts at Describe (Phase 2a).)
  2. Describe → Define — gather requirements conversationally, then decompose them into features.
  3. Specify — turn each feature into a technical SPEC, with an agent acting as tech lead.
  4. Plan — sequence SPECs into deliveries, each a functional, buildable MVP.
  5. Detail — break deliveries into small, typed, dependency-ordered tasks.
  6. Execute — run each task with a built-in adversarial review loop until it clears the grade bar.

92 skills deliver AID: the 14 classic pipeline/on-demand skills above, the /aid-triage suggest-only router, /aid-ask (a Q&A alias of /aid-query-kb), and 76 verb-first shortcut skills (/aid-fix, /aid-create-api, …). When you already know your change, a shortcut skips straight to Execute — the same rigour, proportionate overhead.

Install

Section titled “Install”

AID installs as a global aid CLI; you then run aid add <tool> inside a repository to drop the skills, agents, and Knowledge Base scaffold into your project. Pick the channel for your platform:

Terminal window
curl -fsSL https://raw.githubusercontent.com/AndreVianna/aid-methodology/master/install.sh | bash -s -- --version 2.3.0

Current release: v2.3.0. After install, run aid add claude-code (or another tool), then /aid-config in your AI tool to scaffold the Knowledge Base. The Installation guide covers every channel, per-OS detail, updates, and removal.

How to navigate these docs

Section titled “How to navigate these docs”

The docs are organized to match the order you will actually use AID.

Get Started Install AID, run your first work item, and try the lite quickstart path.
Guides Task-focused walkthroughs: installation, working the pipeline, and maintaining a release.
Concepts The methodology in depth — the pipeline, philosophy, the Knowledge Base, and the FAQ.
Reference Exhaustive lookups: CLI, skills, agents, the KB, settings, artifacts, and the glossary.

Report an issue with this page →