AIAP (AI-Augmented Project) is a universal, non-intrusive framework for integrating AI agents into software development workflows across any technology stack. Add a simple .aiap/ configuration folder to your existing projects—no code changes required—and gain AI-powered assistance for .NET, Python, Angular, Android, iOS, and more.
AIAP is NOT a project template—it's an AI orchestration framework that works with your existing projects.
Transform software development by providing AI assistants with rich project context across multiple projects and technology stacks. AIAP enables seamless human-AI collaboration through intelligent agent orchestration, without disrupting your existing codebase.
✅ Non-Intrusive: Add only a .aiap/ folder—zero code changes
✅ Multi-Stack: Works with .NET, Python, TypeScript, Java, Go, and more
✅ Multi-Project: Manage multiple projects (different stacks) under unified AI orchestration
✅ Stack-Agnostic: Plugin-based adapters for any technology
✅ No Lock-In: Remove .aiap/ folder to unintegrate—that's it!
Works with ANY Technology Stack:
- ✅ .NET / C#: ASP.NET Core, Entity Framework, Blazor
- ✅ Python: Django, Flask, FastAPI, Data Science
- ✅ TypeScript/JavaScript: Angular, React, Vue, Node.js, Next.js
- ✅ Java: Spring Boot, Jakarta EE
- ✅ Mobile: Android (Kotlin/Java), iOS (Swift/Objective-C), React Native
- ✅ And More: Go, Rust, Ruby, PHP—any stack via plugin adapters
Add AIAP to Your Project in 3 Steps:
- Add
.aiap/folder to your project root - Configure your tech stack and team context
- Start using AI agents—no code changes required!
your-project/
├── .aiap/ # AIAP configuration (ADD THIS)
│ ├── project-context.yml
│ ├── stack-config.yml
│ └── integration-hooks.yml
├── src/ # Your existing source code (UNCHANGED)
├── tests/ # Your existing tests (UNCHANGED)
└── docs/ # Your existing docs (UNCHANGED)
- Repository-Wide AI Instructions: Custom
.github/copilot-instructions.mdprovides project context to GitHub Copilot - Path-Specific Guidance: Specialized instructions for backend code, tests, and documentation
- AI Context Documentation: Dedicated
AGENTS.mdfile with technical details for AI assistants - Query Scripts: 85-95% token reduction through optimized context retrieval
Manage Multiple Projects Under One AIAP System:
Example: One fintech product with 6 different technology stacks:
backend-api-dotnet/(.NET Core)backend-service-dotnet/(.NET Core)ml-service-python/(Python)webapp-angular/(Angular)mobile-android/(Kotlin)mobile-ios/(Swift)
AIAP coordinates AI assistance across ALL projects, understanding cross-project dependencies and impacts.
Context Modes:
- Independent: Work with one project at a time
- Holistic: Coordinate across all projects in a product
10 Specialized AI Agents covering the complete enterprise development lifecycle:
- Stakeholder Agent: Business requirements, ROI analysis, user stories
- Architect Agent: System design, ADRs, technology decisions, scalability
- Developer Agent: Feature implementation, bug fixing, clean code practices
- Tester/QA Agent: Test strategy, automation, coverage analysis, quality assurance
- Documentation Agent: Technical writing, ADRs, API docs, developer guides
- DevOps/Release Agent: CI/CD pipelines, Docker/K8s, IaC, release management
- Security/Audit Agent: Security review, vulnerability scanning, OWASP compliance
- Performance Agent: Performance monitoring, optimization, load testing
- Compliance/Regulator Agent: GDPR, licensing, regulatory compliance
- Change-Management Agent: Feature flags, versioning, impact analysis
Plus Additional Specialists:
- Bug Fix Teammate: Systematic debugging and regression prevention
- Code Reviewer: Automated code quality and security review
- Refactoring Specialist: Code cleanup and quality improvement
- Docs Web Agent: Documentation website management (Docusaurus)
- Pull Request Template: Comprehensive checklist for code reviews
- YAML Issue Templates: Structured bug reports, feature requests, and free writing
- Issue Template Config: Flexible issue creation with both structured templates and blank issues
- Contribution Guidelines: Clear standards for all contributors
- Code Owners: Automatic review request routing
This repository includes a complete .NET example demonstrating AIAP integration:
- Complete Working Implementation: Full CRUD API with sample User entity
- Domain-driven design principles
- Clear layer separation (Domain, Application, Infrastructure, Presentation)
- SOLID principles throughout
- Comprehensive testing structure (29 passing tests)
- Entity Framework Core with in-memory database
- FluentValidation for input validation
Note: This is ONE example. AIAP works with ANY stack (Python, Angular, Java, etc.)
- GitHub Actions Workflows: Automated build, test, and code coverage
- CodeQL Security Scanning: Automated vulnerability detection
- Dependency Review: Automatic checks for vulnerable dependencies
- Docker Support: Multi-stage Dockerfile and docker-compose
- Health Checks: Built-in health endpoint for monitoring
- AIAP Principles: Complete specifications, standards, and protocols
- Architecture Decision Records: 5+ ADRs documenting key decisions
- Multi-Project Architecture Guide: Technical deep-dive into AIAP's multi-stack support
- Agent Profiles: 18+ specialized agent profiles with MCP integration
- Query Scripts: Token-optimized documentation retrieval
- Integration Guides: Step-by-step guides for each technology stack
AIAP works with YOUR existing projects—no need to create new ones.
# 1. Navigate to your existing project
cd ~/my-projects/payment-gateway
# 2. Initialize AIAP (creates .aiap/ configuration folder)
aiap init --stack dotnet --interactive
# Or for Python: aiap init --stack python
# Or for Angular: aiap init --stack typescript
# 3. Validate configuration
aiap validate
# 4. Start using AI agents
/agent root "Review the architecture of this project"That's it! Your project now has AI-augmented capabilities without any code changes.
The Red Root Agent is your primary interface to the AIAP system:
# Verify root agent is ready
./tools/setup-root-agent.sh
# Invoke the root agent
/agent root "Your task description here"
# Examples:
/agent root "Fix the authentication bug in UserService.cs"
/agent root "Add password reset with email verification"
/agent root "Review the payment module for security issues"📖 Full Documentation:
- Root Agent Quick Start - Get started in 5 minutes
- AIAP Integration Guide - Complete protocol reference
- AIAP Multi-Project Architecture - Technical deep-dive
- AIAP Principles - Complete specifications
- Vision History - Complete vision evolution
🎓 Token Savings:
- Simple task: 90% reduction (1,500 vs 15,000 tokens)
- Medium task: 94% reduction (12,000 vs 215,000 tokens)
- Complex task: 98% reduction (48,000 vs 2,000,000 tokens)
This repository includes a complete .NET example to demonstrate AIAP integration:
# Clone this repository
git clone https://github.com/tlejmi/ai-augmented-project-template.git
cd ai-augmented-project-template
# The .NET example is in src/dotnet/
cd src/dotnet
# Restore dependencies
dotnet restore
# Build the solution
dotnet build
# Run tests
dotnet test
# Run the API
dotnet run --project WebApiVisit https://localhost:5001 to see the example API with Swagger UI.
Note: The .NET example demonstrates AIAP integration patterns but is NOT the primary purpose of this repository. AIAP is a framework that works with ANY project.
For AIAP Framework:
- Git
- GitHub Copilot (optional but recommended)
- Your existing project (any stack)
For .NET Example (optional):
- .NET 8 SDK or later
- Git
- Docker (optional, for containerized development)
- Visual Studio 2022, VS Code, or JetBrains Rider
- GitHub Copilot (optional but recommended)
This template uses a layered documentation approach:
- README.md (this file): Project overview and quick start
- CONTRIBUTING.md: Contribution guidelines and workflow
- docs/: Additional guides and documentation
- AGENTS.md: Technical context, build instructions, and conventions
- .github/copilot-instructions.md: Repository-wide AI instructions
- .github/instructions/: Path-specific instructions (backend, tests, docs)
- .github/agents/: Specialized AI agent profiles
- .mcp.json: Model Context Protocol configuration (for external CLI tools, not VS Code)
- .github/MCP_CONFIGURATION.md: MCP configuration reference
This template includes 10 specialized AI agent profiles for enterprise-scale development. Invoke them easily using short names:
# Define business requirements and user stories
@copilot /agent stakeholder
"Create user stories for a password reset feature"# Design system architecture and make technical decisions
@copilot /agent architect
"Design a microservices architecture for the order management system"# Implement features with clean code practices
@copilot /agent dev
"Implement the user authentication feature following SOLID principles"# Create comprehensive test strategies
@copilot /agent qa
"Create unit and integration tests for the payment service"# Write technical documentation and ADRs
@copilot /agent docs
"Create an ADR for choosing PostgreSQL over MongoDB"# Set up CI/CD pipelines and deployments
@copilot /agent devops
"Create a GitHub Actions workflow for deploying to Azure"# Review code for security vulnerabilities
@copilot /agent security
"Review this authentication code for security vulnerabilities"# Optimize application performance
@copilot /agent perf
"Optimize these database queries and implement caching"# Ensure GDPR and regulatory compliance
@copilot /agent compliance
"Implement GDPR data subject rights (access, erasure, portability)"# Manage feature flags and releases
@copilot /agent change-mgmt
"Create a feature flag strategy for gradual rollout"# Bug fixing
@copilot /agent bugfix
"Debug the authentication timeout issue"
# Code review
@copilot /agent review
"Review this PR for code quality and security issues"
# Refactoring
@copilot /agent refactor
"Refactor this service to follow SOLID principles"See AGENTS.md for complete agent reference and AI Agent Profiles for detailed capabilities.
| Short Name | Agent | Example Use Case |
|---|---|---|
stakeholder |
Stakeholder Agent | Define user stories and acceptance criteria |
architect |
Architect Agent | Design system components and ADRs |
dev |
Developer Agent | Implement features with clean code |
qa |
Tester/QA Agent | Create comprehensive test suites |
docs |
Documentation Agent | Write ADRs and technical docs |
devops |
DevOps/Release Agent | Set up deployment pipelines |
security |
Security/Audit Agent | Security review and vulnerability scanning |
perf |
Performance Agent | Optimize queries and implement caching |
compliance |
Compliance Agent | GDPR compliance and licensing |
change-mgmt |
Change Management Agent | Feature flags and version management |
bugfix |
Bug Fix Teammate | Systematic debugging |
review |
Code Reviewer | Automated code review |
refactor |
Refactoring Specialist | Code quality improvement |
Important: GitHub Copilot in VS Code has built-in MCP capabilities. No
.mcp.jsonconfiguration is needed for GitHub Copilot.
This repository includes MCP server configuration for external CLI tools (like Copilot CLI) and documents how GitHub Copilot's built-in MCP features work.
All GitHub Copilot agents in this repository automatically have access to:
- GitHub MCP Server (built-in) - Repository operations, code search, issue/PR management
- Web Fetch (built-in) - HTTP/HTTPS requests and external APIs
- Memory (built-in) - Session context and state management
- Time (built-in) - Timestamps, durations, and date utilities
- Sequential Thinking (built-in) - Step-by-step reasoning and complex problem solving
For external CLI tools (not GitHub Copilot in VS Code), the repository includes:
.mcp.json: MCP server definitions for CLI tools like Copilot CLI.github/MCP_CONFIGURATION.md: Reference guide explaining VS Code vs CLI usage
GitHub Copilot in VS Code does NOT use .mcp.json - MCP capabilities are built-in and configured via agent profiles in .github/agents/*.agent.md.
For detailed information:
- MCP Integration Guide - Comprehensive guide
- MCP Configuration Reference - Quick reference
- Official MCP Documentation - Protocol specification
This template includes a fully functional sample application demonstrating all architectural patterns:
- User Entity: Complete domain entity with business logic
- Email validation and normalization
- Active/inactive status management
- Audit fields (CreatedAt, UpdatedAt)
- CRUD API: Full REST API with 5 endpoints
GET /api/users- List all usersGET /api/users/{id}- Get user by IDPOST /api/users- Create new userPUT /api/users/{id}- Update userDELETE /api/users/{id}- Delete userPOST /api/users/{id}/deactivate- Deactivate user
- Validation: FluentValidation rules for all inputs
- Service Layer: Business logic separation
- Repository Pattern: Data access abstraction
- DTOs: Proper request/response models
- 16 Core Tests: User entity unit tests
- 7 Application Tests: UserService unit tests with Moq
- 6 Integration Tests: Full API endpoint tests
- AAA Pattern: Arrange-Act-Assert structure throughout
- FluentAssertions: Readable test assertions
- In-Memory Database: Easy to run without external dependencies
- Swagger UI: Interactive API documentation at root path
- Structured Logging: Serilog configuration with console and file outputs
- Health Endpoint:
/healthfor monitoring
/
├── .github/ # GitHub-specific configs
│ ├── agents/ # AI agent profiles (10 enterprise + specialists)
│ ├── instructions/ # Path-specific Copilot instructions
│ ├── workflows/ # GitHub Actions CI/CD
│ └── copilot-instructions.md
├── docs/ # Human-authored documentation
│ ├── architecture/ # ADRs, system design, diagrams
│ ├── guides/ # Developer guides
│ └── processes/ # Development processes
├── docs-site/ # Docusaurus documentation website
├── src/ # Source code (multi-stack)
│ ├── dotnet/ # .NET/C# stack ⭐ UPDATED
│ │ ├── Core/ # Domain layer (entities, interfaces)
│ │ ├── Application/ # Application layer (use cases, services)
│ │ ├── Infrastructure/ # Infrastructure (database, repositories)
│ │ └── WebApi/ # Presentation layer (controllers, DTOs)
│ ├── python/ # Python stack (future)
│ ├── typescript/ # TypeScript/Node.js stack (future)
│ └── shared/ # Cross-stack contracts and schemas
├── tests/ # Test code (multi-stack)
│ ├── dotnet/ # .NET test projects ⭐ UPDATED
│ │ ├── Core.Tests/ # Domain unit tests
│ │ ├── Application.Tests/ # Application unit tests
│ │ ├── Infrastructure.Tests/ # Infrastructure unit tests
│ │ └── Integration.Tests/ # API integration tests
│ ├── python/ # Python tests (future)
│ ├── typescript/ # TypeScript tests (future)
│ └── e2e/ # Cross-stack end-to-end tests
├── tools/ # Development tools & utilities
│ ├── scripts/ # Build, deploy, migration scripts
│ ├── validators/ # Validation scripts (metadata, artifacts, agents)
│ ├── generators/ # Code/doc generators
│ └── analyzers/ # Code analysis tools
├── config/ # Configuration files
│ ├── docker/ # Docker configs (Dockerfile.dotnet, docker-compose.yml)
│ ├── ci/ # CI/CD configs
│ └── environments/ # Environment-specific configs
├── artifacts/ # AI-generated outputs (git-ignored workspace)
│ ├── analysis/ # In-depth analyses
│ ├── reports/ # Structured reports (date-organized)
│ ├── summaries/ # Concise summaries
│ └── workspace/ # Temporary (git-ignored)
├── specs/ # Formal specifications
│ ├── agents/ # AI agent specifications
│ ├── api/ # API specifications (OpenAPI)
│ └── orchestration/ # Multi-agent orchestration
└── templates/ # Templates & blueprints
├── agent-outputs/ # AI output templates
└── code/ # Code templates
Key Directories:
tools/- Development automation, validators, and utilitiesconfig/- Centralized configuration for Docker, CI/CD, and environmentssrc/{stack}/- Multi-stack source organization (dotnet, python, typescript, shared) ⭐ UPDATEDtests/{stack}/- Stack-specific test projects matching src/ structure ⭐ UPDATEDartifacts/- AI-generated content storage (following ARTIFACT_GUIDELINES.md)docs/- Human-authored documentation (ADRs, guides, references)specs/- Formal specifications for agents, APIs, and data models
This template follows Clean Architecture principles:
┌─────────────────────────────────────────┐
│ Presentation Layer │
│ (WebApi/Controllers) │
├─────────────────────────────────────────┤
│ Application Layer │
│ (Use Cases, Commands, Queries) │
├─────────────────────────────────────────┤
│ Infrastructure Layer │
│ (Database, External Services, Repos) │
├─────────────────────────────────────────┤
│ Domain Layer │
│ (Entities, Value Objects, Logic) │
└─────────────────────────────────────────┘
Key Principles:
- Dependencies point inward (outer layers depend on inner layers)
- Business logic isolated in the Core/Domain layer
- Infrastructure concerns abstracted by interfaces
- Testable at every layer
- .NET 8 (C#): Modern, cross-platform framework (LTS)
- ASP.NET Core: Web API with minimal APIs and controllers
- Entity Framework Core: ORM with in-memory database (easily swappable to SQL Server, PostgreSQL, etc.)
- Serilog: Structured logging to console and file
- Swashbuckle: OpenAPI/Swagger documentation with XML comments
- xUnit: Modern testing framework
- FluentAssertions: Readable and expressive assertions
- Moq: Mocking framework for unit tests
- Microsoft.AspNetCore.Mvc.Testing: Integration testing support
- FluentValidation: Fluent API for validation rules
- CodeQL: Security vulnerability scanning
- Code Coverage: Automated test coverage reporting
- GitHub Actions: CI/CD workflows
- Docker: Multi-stage containerization
- Health Checks: Built-in health monitoring endpoints
- Directory.Packages.props: Centralized NuGet package version management
- global.json: .NET SDK version pinning
Once installed, you can create new projects with various options:
# Basic usage with defaults (.NET 8, Docker, Swagger, Tests)
dotnet new ai-dotnet-template -n MyProject
# Use .NET 9
dotnet new ai-dotnet-template -n MyProject --Framework net9.0
# Without Docker
dotnet new ai-dotnet-template -n MyProject --UseDocker false
# Without tests
dotnet new ai-dotnet-template -n MyProject --IncludeTests false
# Minimal setup (no Docker, no GitHub Actions, no tests)
dotnet new ai-dotnet-template -n MyProject --UseDocker false --IncludeGitHubActions false --IncludeTests falseAvailable Template Options:
| Option | Type | Default | Description |
|---|---|---|---|
--Framework |
choice | net8.0 |
Target framework (net8.0 or net9.0) |
--UseDocker |
bool | true |
Include Docker support |
--UseSwagger |
bool | true |
Include Swagger/OpenAPI |
--UseSerilog |
bool | true |
Use Serilog logging |
--IncludeTests |
bool | true |
Include test projects |
--IncludeGitHubActions |
bool | true |
Include CI/CD workflows |
All commits follow the Conventional Commits specification:
<type>(<scope>): <description>
[optional body]
[optional footer]
Examples:
feat(auth): add password reset functionality
fix(api): handle null reference in user controller
docs(readme): update installation instructions
test(users): add integration tests for user serviceThis template is designed for human-AI collaboration:
- AI agents have full project context through structured documentation
- Specialized agents excel at specific tasks (testing, planning, reviewing)
- Consistent standards apply to both human and AI contributions
- Human oversight ensures quality and alignment with business goals
We welcome contributions from both humans and AI agents! Please read our Contributing Guidelines for details on:
- Code of conduct
- Development workflow
- Coding standards
- Testing requirements
- Pull request process
- Working with AI agents
- Complete .NET 8 solution with Clean Architecture
- Sample CRUD API with User entity
- Comprehensive test suite (29 tests)
- GitHub Copilot integration with custom instructions
- 10 Enterprise AI Agent Profiles (Stakeholder, Architect, Developer, Tester/QA, Documentation, DevOps/Release, Security/Audit, Performance, Compliance/Regulator, Change-Management)
- Additional specialized agents (Bug Fix, Code Reviewer, Refactoring, Docs Web)
- GitHub Actions CI/CD workflows
- CodeQL security scanning
- Docker containerization
- Swagger/OpenAPI documentation
- .NET template system
- YAML issue templates
- Centralized package management
- Additional database providers (SQL Server, PostgreSQL)
- Authentication & authorization (JWT, OAuth)
- Rate limiting and API versioning
- Redis caching support
- Message queue integration (RabbitMQ, Azure Service Bus)
- Kubernetes deployment manifests
- Multi-language support (TypeScript, Python, Java variants)
- Advanced monitoring and observability (OpenTelemetry)
- GraphQL support option
- AI Agent orchestration and workflow automation
Security is a top priority. This template includes:
- Input validation guidelines
- Security-focused code review checklist
- No secrets in code (use environment variables)
- SQL injection prevention
- Authentication and authorization patterns
Report security vulnerabilities privately through GitHub Security Advisories.
This project is licensed under the MIT License - see the LICENSE file for details.
- Inspired by Clean Architecture by Robert C. Martin
- Built with GitHub Copilot
- Based on .NET architectural patterns from Microsoft
- Documentation: Check AGENTS.md for detailed technical information
- Issues: Report bugs or request features via GitHub Issues
- Discussions: Ask questions or share ideas in GitHub Discussions
Built with ❤️ for human-AI collaboration in software development