Build an Autonomous Coding Agent Pipeline for Your Team

# Install Aider
pip install aider-chat

# Configure for the project
cd /path/to/project

# .aider.conf.yml — Project-level configuration
cat > .aider.conf.yml << 'EOF'
model: claude-sonnet-4-20250514
edit-format: diff                        # Use diff format for cleaner edits
auto-commits: true                       # Commit changes automatically
auto-lint: true                          # Run linter after changes
lint-cmd: "npm run lint:fix"
auto-test: true                          # Run tests after changes
test-cmd: "npm test"
map-tokens: 2048                         # Repository map token budget
read:                                    # Always include these for context
  - src/types/index.ts
  - src/lib/db/schema.ts
  - .cursor/rules/backend.mdc
EOF

# scripts/auto_resolve_issues.py — Process GitHub issues with Aider
import subprocess
import json
from github import Github

gh = Github(os.environ["GITHUB_TOKEN"])
repo = gh.get_repo("company/backend")

def process_issue(issue):
    """Resolve a GitHub issue using Aider autonomously.

    Args:
        issue: GitHub issue object with 'ai-ready' label

    Flow:
        1. Create a branch from main
        2. Run Aider with the issue description as prompt
        3. If tests pass, create a PR
        4. Link PR to the issue
    """
    branch_name = f"ai/{issue.number}-{slugify(issue.title)}"

    # Create branch
    subprocess.run(["git", "checkout", "-b", branch_name, "origin/main"], check=True)

    # Build the prompt from issue context
    prompt = f"""Fix GitHub issue #{issue.number}: {issue.title}

Description:
{issue.body}

Requirements:
- Follow existing code patterns in the project
- Add or update tests for any changed logic
- Update relevant documentation
- Keep changes minimal and focused on the issue"""

    # Run Aider with the prompt
    result = subprocess.run(
        ["aider", "--yes-always", "--message", prompt],
        capture_output=True,
        text=True,
        timeout=300,                       # 5 minute timeout
    )

    if result.returncode == 0:
        # Push and create PR
        subprocess.run(["git", "push", "origin", branch_name], check=True)
        pr = repo.create_pull(
            title=f"fix: resolve #{issue.number} — {issue.title}",
            body=f"Closes #{issue.number}\n\nAutonomously resolved by Aider.\n\n{result.stdout[-500:]}",
            head=branch_name,
            base="main",
        )
        issue.create_comment(f"🤖 Created PR #{pr.number} to resolve this issue.")
        return pr
    else:
        issue.create_comment(
            f"🤖 Attempted automatic resolution but encountered issues:\n```\n{result.stderr[-300:]}\n```\nNeeds human attention."
        )
        return None

# Process all ai-ready issues
for issue in repo.get_issues(labels=["ai-ready"], state="open"):
    print(f"Processing #{issue.number}: {issue.title}")
    process_issue(issue)

// .continue/config.json — Team-shared Continue configuration
{
  "models": [
    {
      "title": "Claude Sonnet (Fast)",
      "provider": "anthropic",
      "model": "claude-sonnet-4-20250514",
      "apiKey": "${ANTHROPIC_API_KEY}"
    },
    {
      "title": "Claude Opus (Complex)",
      "provider": "anthropic",
      "model": "claude-opus-4-20250514",
      "apiKey": "${ANTHROPIC_API_KEY}"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Codestral",
    "provider": "mistral",
    "model": "codestral-latest"
  },
  "contextProviders": [
    { "name": "code", "params": {} },
    { "name": "docs", "params": {} },
    { "name": "diff", "params": {} },
    { "name": "terminal", "params": {} },
    { "name": "open", "params": {} },
    { "name": "codebase", "params": {} },
    {
      "name": "url",
      "params": { "url": "https://docs.company.com/api-reference" }
    }
  ],
  "slashCommands": [
    { "name": "commit", "description": "Generate a commit message" },
    { "name": "review", "description": "Review selected code for bugs" },
    { "name": "test", "description": "Generate tests for selected code" },
    { "name": "docs", "description": "Generate JSDoc documentation" }
  ],
  "customCommands": [
    {
      "name": "api-endpoint",
      "description": "Scaffold a new tRPC endpoint with validation, tests, and docs",
      "prompt": "Create a new tRPC endpoint based on this description. Follow the patterns in src/server/routers/. Include: Zod input schema, the procedure implementation, a test file, and update the router index. {{{ input }}}"
    }
  ]
}

## Cline Workflow for Major Refactoring

Cline runs in VS Code as an autonomous agent that:
1. Plans the changes (shows you the plan first)
2. Reads relevant files across the codebase
3. Makes changes file by file (you approve each)
4. Runs tests after each change
5. Rolls back if tests fail

### Example: Migrate from Prisma to Drizzle ORM

Prompt to Cline:
"Migrate our database layer from Prisma to Drizzle ORM.
The Prisma schema is at prisma/schema.prisma.
Create equivalent Drizzle schema in src/db/schema.ts.
Update all repository files in src/server/db/repos/ to use Drizzle query syntax.
Update the database client initialization in src/server/db/index.ts.
Keep all existing tests passing — update test mocks as needed."

### Cline's approach:
1. Reads prisma/schema.prisma to understand all models
2. Creates src/db/schema.ts with Drizzle table definitions
3. Updates each repo file one at a time (you review each diff)
4. Updates db client initialization
5. Runs `npm test` after each file change
6. If tests fail, proposes fixes or rolls back