ADD 2.0 Universal Configuration for Aider

Complete Aider configuration implementing the ADD (Agent-Driven Development) 2.0 Universal methodology with contract-first development, multi-agent coordination, and phase-aware workflows.

What This Skill Does

Configures Aider to follow ADD 2.0 methodology with:

Phase-aware development (DISCOVER → DESIGN → PREPARE → BUILD → VALIDATE → DELIVER → SUPPORT → EVOLVE)

Contract-first implementation in BUILD phase

Multi-agent coordination via Git

Automated documentation tracking

Phase-specific commit message templates

Contract compliance validation

Instructions

Step 1: Create Configuration File

Create `.aider.conf.yml` in your project root with the following content:

```yaml

ADD 2.0 Universal Configuration for Aider

model: claude-3-5-sonnet-20241022

editor-model: claude-3-5-sonnet-20241022

architect-model: claude-3-5-sonnet-20241022

Use architect mode by default (plan first, then implement)

architect: true

Git Integration

auto-commits: true

commit-message-template: |

{msg}

ADD 2.0 Phase: {phase}

Contract Compliance: {contract_status}

Co-authored-by: Aider <[email protected]>

dirty-commits: false

show-diffs: true

Context Files (always include)

read:

- add-project.yaml

- README.md

- docs/discovery.md

- docs/design.md

- docs/interfaces.md

- docs/journal.md

Excluded patterns

ignore:

- "*.log"

- "node_modules/*"

- ".git/*"

- "dist/*"

- "build/*"

- ".next/*"

- "coverage/*"

test-cmd: npm test

lint: true

lint-cmd: npm run lint

ADD 2.0 Custom System Prompt

system-prompt: |

You are an AI pair programmer following ADD (Agent-Driven Development) 2.0 Universal methodology.

CRITICAL RULES:

1. ALWAYS read project documentation first (add-project.yaml, docs/*.md)

2. Determine current phase from add-project.yaml version field

3. In BUILD phase (v0.4.x), read docs/interfaces.md for contracts BEFORE implementing

4. Implement EXACTLY to contract specification - no deviations

5. Use mocks for dependencies not yet implemented

6. Never commit changes across different phases

7. Validate exit criteria before considering phase complete

8. Update docs/journal.md with progress

PHASES:

- v0.1.x DISCOVER: Research, requirements, analysis

- v0.2.x DESIGN: Architecture, contracts, design

- v0.3.x PREPARE: Setup, configuration, tools

- v0.4.x BUILD: Implementation (CONTRACT-FIRST if multi-agent)

- v0.5.x VALIDATE: Testing, QA, validation

- v0.6.x DELIVER: Deployment, launch

- v0.7.x SUPPORT: Maintenance, bug fixes

- v0.8.x EVOLVE: Optimization, enhancements

CONTRACT-FIRST (in BUILD phase):

1. Read docs/interfaces.md first

2. Implement exactly as specified

3. Use mocks for missing dependencies

4. Add contract compliance comments

5. Include tests validating contract

When in doubt, ask which phase we're in and what the goal is.

ask-before-commit: true

pretty: true

check-update: false

```

Step 2: Initialize ADD 2.0 Project Structure

Create required project documentation files:

```bash

mkdir -p docs

touch add-project.yaml docs/discovery.md docs/design.md docs/interfaces.md docs/journal.md

```

Step 3: Configure add-project.yaml

Set up your project metadata with version indicating current phase:

```yaml

name: your-project

version: 0.1.0 # Phase: DISCOVER (0.1.x), DESIGN (0.2.x), BUILD (0.4.x), etc.

phase: DISCOVER

```

Step 4: Start Phase-Aware Development Session

**Basic session:**

```bash

aider --config .aider.conf.yml

```

**Check current phase and goals:**

```bash

aider --message "What phase are we in? Show exit criteria."

```

**Architect mode for planning:**

```bash

aider --architect --message "Plan implementation of user authentication"

```

Step 5: BUILD Phase - Contract-First Implementation

In BUILD phase (v0.4.x), always start by reviewing contracts:

```bash

1. Review contracts

aider --message "Read docs/interfaces.md and list all contracts"

2. Implement per contract

aider --message "Implement POST /api/users following contract in docs/interfaces.md"

3. Validate compliance

aider --message "Run tests and validate contract compliance"

```

Step 6: Multi-Agent Coordination (Advanced)

For parallel development with multiple Aider instances:

**Backend agent:**

```bash

git checkout -b feature/v0.4.x-backend

aider --config .aider.conf.yml \

--read src/backend/ \

--read docs/interfaces.md \

--message "Implement API endpoints per contracts"

```

**Frontend agent (in separate terminal):**

```bash

git checkout -b feature/v0.4.x-frontend

aider --config .aider.conf.yml \

--read src/frontend/ \

--read docs/interfaces.md \

--message "Implement UI components per contracts (use mocks)"

```

**Coordinate via Git:**

```bash

Backend completes

git commit -m "build(api): all endpoints ready

Frontend team: you can now replace mocks with real API

All contracts from docs/interfaces.md implemented

Tests: 20/20 passing"

git push

Frontend pulls and integrates

git pull

aider --message "Backend API is ready. Replace mocks with real API client"

```

Step 7: Phase-Specific Commit Messages

**DISCOVER phase:**

```

discover(requirements): document user authentication requirements

Research findings documented in docs/discovery.md

ADD 2.0 Phase: DISCOVER

```

**DESIGN phase:**

```

design(architecture): define API contracts for user service

All endpoints specified in docs/interfaces.md

ADD 2.0 Phase: DESIGN

Contract Compliance: N/A (defining contracts)

```

**BUILD phase:**

```

build(api): implement POST /api/users endpoint

Implements contract from docs/interfaces.md:

Input validation: name, email required

Email format validation

Duplicate check

Output: {id, name, email, created_at}

Error handling: 400, 409, 500

ADD 2.0 Phase: BUILD

Contract Compliance: Yes

Tests: Included (5/5 passing)

```

Step 8: Regular Progress Tracking

Update journal with progress:

```bash

aider --message "Update docs/journal.md with today's progress"

```

Step 9: Phase Transition Validation

Before advancing to next phase:

```bash

aider --message "Check all exit criteria for BUILD phase"

```

Key Features

**Phase-Aware Development**: Automatic phase detection from version field

**Contract-First**: Forces reading docs/interfaces.md before BUILD implementation

**Multi-Agent Ready**: Git-based coordination between Aider instances

**Auto-Documentation**: Always includes project docs in context

**Compliance Tracking**: Commit messages include contract compliance status

**Test Integration**: Runs tests before commits

**Journal Tracking**: Encourages progress documentation

Phase Guide

|-------|---------|-------|-----------|

| PREPARE | v0.3.x | Setup, configuration | N/A |

Troubleshooting

**Aider doesn't follow contracts:**

```bash

aider --message "Read docs/interfaces.md for POST /api/users contract, then implement exactly as specified"

```

**Commits span multiple phases:**

```bash

aider --message "This is BUILD phase work only. Don't include DESIGN files."

```

**Multi-agent conflicts:**

Use separate branches per agent

Coordinate via Git commits

Merge after both complete

References

ADD 2.0 Documentation: `/var/add/ADD-UNIVERSAL.md`

Multi-Agent Coordination: `/var/add/agentes/COORDINACION-PARALELA.md`

Aider Documentation: https://aider.chat/docs

ADD 2.0 Website: https://agenticdriven.dev/2.0

Notes

Configuration enforces contract-first implementation in BUILD phase

Multi-agent coordination uses Git as message-passing system

Phase transitions require explicit exit criteria validation

All implementations must include contract compliance documentation

Journal updates track progress across phases

ADD 2.0 Universal Configuration for Aider

ADD 2.0 Universal Configuration for Aider

What This Skill Does

Instructions

Step 1: Create Configuration File

ADD 2.0 Universal Configuration for Aider

Use architect mode by default (plan first, then implement)

Git Integration

Context Files (always include)

Excluded patterns

ADD 2.0 Custom System Prompt

Step 2: Initialize ADD 2.0 Project Structure

Step 3: Configure add-project.yaml

Step 4: Start Phase-Aware Development Session

Step 5: BUILD Phase - Contract-First Implementation

1. Review contracts

2. Implement per contract

3. Validate compliance

Step 6: Multi-Agent Coordination (Advanced)

Backend completes

Frontend pulls and integrates

Step 7: Phase-Specific Commit Messages

Step 8: Regular Progress Tracking

Step 9: Phase Transition Validation

Key Features

Phase Guide

Troubleshooting

References

Notes

Reviews (0)