Skip to content

gabrielscr/code-agents

BranchesTags

Repository files navigation

AI Agents Collection

Comprehensive collection of 86 specialized AI agents for full-stack development across multiple technologies.

📁 Repository Structure

agents/
├── frontend-ai-agents/          # 13 Frontend agents (React, Angular, Vue, TypeScript, CSS)
├── backend-ai-agents/           # 48 Backend agents
│   ├── python/                 # 5 Python agents (FastAPI, Clean Architecture)
│   ├── golang/                 # 5 Go agents (REST APIs, Performance)
│   ├── java/                   # 5 Java/Spring Boot agents
│   ├── nodejs/                 # 5 Node.js/NestJS agents
│   ├── ruby/                   # 5 Ruby/Rails agents
│   ├── rust/                   # 5 Rust/Actix agents
│   ├── security/               # 2 Cross-language security agents
│   ├── database/               # 2 Database specialists (SQL, NoSQL)
│   └── testing/                # 1 Backend testing specialist
├── dotnet-ai-agents/backend/    # 11 .NET backend agents
├── flutter-ai-agent/           # 14 Flutter/Dart agents
└── README.md                   # This file

Total: 86 Specialized Professional Agents

🎯 Overview

This repository contains comprehensive sets of specialized AI agents designed to assist with professional software development across multiple technology stacks. Each agent is an expert in a specific domain, ensuring high-quality, consistent, and maintainable code across frontend, backend, and mobile development.

🎨 Frontend Development Agents

Location: frontend-ai-agents/

Specialized agents for modern frontend development with React, Angular, Vue, and CSS frameworks.

📂 Categories

🏗️ Architecture (3 agents)

  • react-architect - React application architecture and project structure
  • angular-architect - Angular modular architecture with standalone components
  • vue-architect - Vue 3 Composition API architecture

🎨 Components (1 agent)

  • react-component-designer - Reusable, accessible React components

📊 State Management (1 agent)

  • react-state-manager - Global state with Zustand, Jotai, Redux Toolkit, TanStack Query

🎨 Styling (2 agents)

  • tailwind-specialist - Tailwind CSS utility-first design
  • css-modules-specialist - Component-scoped CSS Modules

📘 TypeScript (1 agent)

  • typescript-specialist - Advanced TypeScript patterns and best practices

✅ Testing (2 agents)

  • frontend-tester - Unit and integration testing with Vitest/Jest
  • e2e-tester - End-to-end testing with Playwright/Cypress

🔧 Build Tools (2 agents)

  • vite-specialist - Vite configuration and optimization
  • webpack-specialist - Webpack advanced configuration

⚡ Performance (1 agent)

  • frontend-performance-optimizer - Core Web Vitals, bundle optimization, rendering performance

Total: 13 specialized frontend agents

→ View Full Frontend Documentation

🚀 Backend Development Agents

Location: backend-ai-agents/

Specialized agents for backend development across 6 languages with comprehensive coverage.

📂 Categories by Language

🐍 Python (5 agents)

  • python-clean-architecture - Clean Architecture patterns and domain modeling
  • python-fastapi-developer - Modern async REST APIs with FastAPI
  • python-performance-optimizer - Profiling, optimization, caching
  • python-security-specialist - Security best practices and input validation
  • python-tester - pytest patterns and async testing

🔷 Go (5 agents)

  • go-clean-architecture - Idiomatic Go architecture with interfaces
  • go-rest-api-developer - Efficient REST APIs with Gin/Echo
  • go-performance-optimizer - Goroutine patterns and optimization
  • go-security-specialist - Security and input validation
  • go-tester - Table-driven tests and testify

☕ Java (5 agents)

  • spring-architect - Layered architecture and Spring Boot patterns
  • spring-boot-developer - Enterprise REST APIs with Spring Boot
  • spring-performance-optimizer - Caching and async processing
  • spring-security-specialist - Spring Security, JWT, OAuth2
  • spring-tester - JUnit, MockMvc, integration testing

🟢 Node.js (5 agents)

  • nestjs-architect - Modular architecture with dependency injection
  • nestjs-developer - Scalable TypeScript backend with NestJS
  • nodejs-performance-optimizer - Event loop and worker threads optimization
  • nodejs-security-specialist - Helmet, rate limiting, validation
  • nodejs-tester - Jest and Supertest patterns

💎 Ruby (5 agents)

  • rails-architect - MVC architecture and service objects
  • rails-developer - Full-stack MVC with Ruby on Rails
  • rails-performance-optimizer - N+1 query prevention and caching
  • rails-security-specialist - Strong parameters and authentication
  • rails-tester - RSpec, FactoryBot, testing patterns

🦀 Rust (5 agents)

  • rust-clean-architecture - Domain-driven design with Rust
  • rust-actix-developer - High-performance APIs with Actix-web
  • rust-performance-optimizer - Zero-cost abstractions and optimization
  • rust-security-specialist - Type system leverage and validation
  • rust-tester - cargo test and async testing

🔒 Cross-Language (8 agents)

  • backend-security-auditor - OWASP Top 10 and security audits
  • auth-specialist - JWT, OAuth2, session management
  • sql-database-specialist - PostgreSQL, MySQL optimization
  • nosql-database-specialist - MongoDB, Redis patterns
  • backend-tester - Unit, integration, and API testing

Total: 48 specialized backend agents

→ View Full Backend Documentation

🔷 .NET Backend Agents

Location: backend-ai-agents/dotnet/

Specialized agents for .NET backend development, organized by domain expertise.

📂 Categories

🏗️ Architecture (3 agents)

  • dotnet-solution-architect - Solution structure and project organization
  • dotnet-api-designer - RESTful API design and contracts
  • dotnet-data-architect - Entity Framework and database design

💻 Development (3 agents)

  • dotnet-code-implementer - C# code implementation and SOLID principles
  • dotnet-debugger - Debugging and error resolution
  • dotnet-problem-analyst - Complex problem analysis and solutions

⚡ Optimization (2 agents)

  • dotnet-performance-optimizer - Performance optimization and profiling
  • dotnet-ef-specialist - Entity Framework Core specialization

📝 Documentation (1 agent)

  • dotnet-documentation-writer - XML docs, API docs, and technical documentation

🔒 Security (2 agents)

  • dotnet-security-auditor - Security audits and DevSecOps
  • dotnet-security-implementer - Secure code implementation

Total: 11 specialized .NET agents

→ View Full .NET Documentation

🔶 Flutter Development Agents

Location: flutter-ai-agent/

Specialized agents for Flutter/Dart development following Clean Architecture.

📂 Categories

🏗️ Architecture (2 agents)

  • flutter-architect - Clean Architecture and project structure
  • flutter-feature-planner - Feature planning and reference consultation

📡 Data Layer (2 agents)

  • flutter-data-layer - DataSources, Models, and API integration
  • flutter-repository - Repository pattern with Either

🧬 Domain Layer (2 agents)

  • flutter-domain - Entities and repository interfaces
  • flutter-use-cases - Business logic and validation (ONLY layer that validates!)

🎨 Presentation Layer (3 agents)

  • flutter-state - Cubit/Bloc state management
  • flutter-ui - Pages and Widgets implementation
  • flutter-design-system - Design tokens and theme

🔌 Infrastructure (3 agents)

  • flutter-router - GoRouter navigation
  • flutter-di - GetIt dependency injection
  • flutter-services - External services integration

✅ Quality (2 agents)

  • flutter-tester - Testing (unit, widget, integration)
  • flutter-quality - Code review and quality assurance

Total: 14 specialized Flutter agents

→ View Full Flutter Documentation

🚀 Quick Start

Using .NET Agents

1. Identify your task (architecture, development, optimization, etc.)
2. Browse dotnet-ai-agents/backend/ by category
3. Read the agent's markdown file for detailed guidance
4. Follow the agent's patterns and best practices

Example: Need to design an API? → Use dotnet-api-designer

Using Flutter Agents

1. ALWAYS start with flutter-feature-planner
2. Follow Clean Architecture layers: Domain → Data → Presentation
3. Use infrastructure agents (DI, Router) as needed
4. Finish with quality agents (Testing, Code Review)

Example: Implementing a new feature? → Follow the Implementation Workflow

🛠️ IDE Integration

Using with Cursor

Cursor automatically reads .cursorrules file. Simply reference agents in chat:

@frontend-ai-agents/architecture/react-architect.md design React app structure
@backend-ai-agents/python/development/python-fastapi-developer.md create user API
@backend-ai-agents/dotnet/architecture/dotnet-api-designer.md design a REST API
@flutter-ai-agent/domain/flutter-use-cases.md implement authentication usecase

Using with GitHub Copilot

  1. Add to .vscode/settings.json:
{
  "github.copilot.advanced": {
    "instructionsFile": "agents/.github/copilot-instructions.md"
  }
}
  1. Use inline comments to reference patterns:
// Following react-component-designer accessibility guidelines
# Following python-fastapi-developer async patterns
// Following dotnet-security-implementer best practices
// Following flutter-ui guidelines - UI only invokes Cubit

Using with Claude (Web/API)

Simply copy the relevant agent's markdown content into your conversation for context.

Using with Other AI Tools

All agents are standard markdown files - copy their content to any AI tool for guidance.

🎯 When to Use Which Stack

Use Frontend Agents When:

  • ✅ Building web applications (React/Angular/Vue)
  • ✅ Creating responsive, accessible UIs
  • ✅ Implementing modern CSS (Tailwind, CSS Modules)
  • ✅ Managing complex client-side state
  • ✅ Building single-page applications (SPAs)
  • ✅ Optimizing frontend performance

Use Backend Agents When:

  • ✅ Building REST APIs or GraphQL servers
  • ✅ Choosing the right backend language/framework
  • ✅ Implementing authentication and authorization
  • ✅ Designing database schemas and queries
  • ✅ Building microservices architecture
  • ✅ Optimizing backend performance

Use .NET Agents When:

  • ✅ Building enterprise backend services
  • ✅ Working with Entity Framework Core
  • ✅ Implementing business logic in C#
  • ✅ Creating microservices with .NET
  • ✅ Requiring strong type safety
  • ✅ Enterprise security requirements

Use Flutter Agents When:

  • ✅ Building mobile applications (iOS/Android)
  • ✅ Creating cross-platform apps
  • ✅ Implementing Clean Architecture
  • ✅ Managing app state with Cubit/Bloc
  • ✅ Designing responsive mobile UIs
  • ✅ Building high-performance mobile apps

💡 Best Practices

Multi-Agent Workflows

All stacks support multi-agent workflows for complex tasks:

Frontend Feature (React)

1. react-architect           → Design application structure
2. react-component-designer   → Create reusable components
3. react-state-manager        → Implement global state
4. tailwind-specialist        → Style components
5. frontend-tester            → Write tests

Backend API (Python FastAPI)

1. python-clean-architecture  → Design architecture
2. python-fastapi-developer   → Build REST API
3. sql-database-specialist    → Integrate database
4. python-security-specialist → Security review
5. python-tester              → Write comprehensive tests
6. python-performance-optimizer → Optimize performance

Backend API (Go)

1. go-clean-architecture      → Design architecture
2. go-rest-api-developer      → Build REST API
3. sql-database-specialist    → Integrate database
4. go-security-specialist     → Security review
5. go-tester                  → Write tests
6. go-performance-optimizer   → Optimize with goroutines

Backend API (Spring Boot)

1. spring-architect           → Design architecture
2. spring-boot-developer      → Build enterprise API
3. sql-database-specialist    → Implement database
4. spring-security-specialist → Configure security
5. spring-tester              → Write tests
6. spring-performance-optimizer → Optimize performance

.NET Backend Feature

1. dotnet-solution-architect  → Design solution structure
2. dotnet-api-designer        → Design API contracts
3. dotnet-data-architect      → Design data models
4. dotnet-code-implementer    → Implement code
5. dotnet-security-implementer→ Secure code
6. dotnet-documentation-writer→ Document
7. dotnet-performance-optimizer→ Optimize

Flutter Feature

1. flutter-feature-planner    → Plan (consult references)
2. flutter-domain             → Create entities & interfaces
3. flutter-use-cases          → Implement business logic
4. flutter-data-layer         → Implement data access
5. flutter-repository         → Implement repositories
6. flutter-di                 → Register dependencies
7. flutter-state              → Implement state management
8. flutter-ui                 → Build UI
9. flutter-router             → Register routes
10. flutter-tester            → Write tests
11. flutter-quality           → Code review

Proactive Security & Quality

All stacks emphasize security and quality:

  • Always use security agents before deployment
  • Always use quality/testing agents after implementation
  • Never skip architectural planning agents
  • Always follow the recommended workflow

📊 Agent Comparison

Feature Frontend Backend .NET Flutter
Total Agents 13 48 11 14
Languages JS/TS Python, Go, Java, Node.js, Ruby, Rust C# Dart
Frameworks React/Angular/Vue FastAPI/Gin/Spring/NestJS/Rails/Actix ASP.NET Core Flutter
Architecture 3 architects 6 per language (30 total) 3 2
State Management ✅ 1 agent N/A N/A ✅ Cubit/Bloc
Styling ✅ 2 agents N/A N/A ✅ Design System
Security ✅ General ✅ 8 agents ✅ 2 agents ✅ Best practices
Testing ✅ 2 agents ✅ 6 agents ✅ Integrated ✅ 2 agents
Performance ✅ 1 agent ✅ 6 agents ✅ 1 agent ✅ Best practices
Build Tools ✅ 2 agents N/A N/A N/A
Organization By category By language By domain By Clean Architecture
Focus Web/Mobile UI Multi-language APIs Enterprise Backend Mobile/Cross-platform

🎓 Learning Path

For Frontend Developers

  1. Choose Your Framework

    • React (most popular, great ecosystem)
    • Angular (enterprise, opinionated)
    • Vue (progressive, flexible)

  2. Start with Architecture

    • Use framework-specific architect agent
    • Understand project structure
    • Learn state management patterns

  3. Build Components

    • Use component designer agent
    • Focus on accessibility
    • Learn modern CSS (Tailwind or CSS Modules)

  4. Master State Management

    • Built-in state first
    • Server state with TanStack Query
    • Global state when needed

  5. Testing & Quality

    • Unit tests with Vitest/Jest
    • Integration tests with Testing Library
    • E2E tests with Playwright

For Backend Developers

  1. Choose Your Language

    • Python (easiest, great for APIs and data)
    • Go (performance, concurrency)
    • Java (enterprise, mature ecosystem)
    • Node.js (JavaScript, full-stack)

  2. Learn Framework

    • Use language-specific developer agent
    • Build a simple REST API
    • Understand MVC/Clean Architecture

  3. Master Database

    • Learn SQL (PostgreSQL recommended)
    • Understand ORM patterns
    • Query optimization

  4. Security First

    • Authentication (JWT, OAuth2)
    • Authorization (RBAC)
    • Input validation
    • Security best practices

  5. Testing & DevOps

    • Unit and integration tests
    • API testing
    • Docker/Kubernetes
    • CI/CD pipelines

For .NET Developers

  1. Start with dotnet-solution-architect to understand project structure
  2. Learn API design with dotnet-api-designer
  3. Master data with dotnet-data-architect
  4. Implement with dotnet-code-implementer
  5. Secure with security agents
  6. Document and optimize

For Flutter Developers

  1. Understand architecture with flutter-architect
  2. Always plan features with flutter-feature-planner
  3. Master Clean Architecture layers in order: Domain → Data → Presentation
  4. Learn infrastructure: DI, Router, Services
  5. Ensure quality with testing and code review agents

🔗 Additional Resources

Frontend Resources

Backend Resources (Multi-language)

.NET Resources

Flutter Resources

📈 Project Status

Stack Agents Status Last Updated
Frontend 13 ✅ Complete October 2025
Backend (Multi-language) 48 ✅ Complete October 2025
.NET Backend 11 ✅ Complete October 2025
Flutter 14 ✅ Complete October 2025

Total Agents: 86 Specialized Professional Agents

🤝 Contributing

To add new agents or improve existing ones:

  1. Follow the established structure

    • Use frontmatter with name, description, and model
    • Organize by domain or layer
    • Include examples and best practices

  2. Maintain consistency

    • Follow the naming convention (dotnet-* or flutter-*)
    • Use clear, professional markdown formatting
    • Include emojis for visual hierarchy

  3. Update documentation

    • Update the relevant README (dotnet, flutter, or main)
    • Add to the quick reference tables
    • Update totals and statistics

  4. Test thoroughly

    • Ensure examples are accurate
    • Verify all links work
    • Check markdown rendering

⚙️ Technical Details

Model Information

All agents use: Claude Sonnet 4.5 (claude-sonnet-4-5-20250929)

Why This Model?

  • Maximum code quality
  • Enterprise-grade outputs
  • Consistent architectural decisions
  • Deep understanding of best practices
  • Optimal performance for complex tasks

👤 Author

Gabriel Rocha

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Copyright (c) 2025 Gabriel Rocha

🎯 Key Principles

All agent sets follow these core principles:

Frontend Agents

  • ✅ Modern framework patterns
  • ✅ Type safety with TypeScript
  • ✅ Accessibility first (WCAG 2.1 AA)
  • ✅ Performance optimization
  • ✅ Component reusability
  • ✅ Responsive design (mobile-first)

Backend Agents

  • ✅ Language-specific best practices
  • ✅ Security-first approach
  • ✅ Clean architecture patterns
  • ✅ Type safety where applicable
  • ✅ Comprehensive testing
  • ✅ Performance optimization

.NET Agents

  • ✅ SOLID principles
  • ✅ Clean Architecture
  • ✅ Security-first approach
  • ✅ Performance optimization
  • ✅ Comprehensive documentation

Flutter Agents

  • ✅ Clean Architecture (strict)
  • ✅ Zero tolerance for quality issues
  • ✅ Always consult reference projects
  • ✅ Complete functionality (no empty actions)
  • ✅ Design system compliance

🌟 Highlights

Unique Features

Frontend Agents

  • Multi-framework support for React, Angular, and Vue
  • Styling specialists for Tailwind CSS and CSS Modules
  • State management experts for each framework
  • Accessibility-first approach in all components
  • Performance optimization built into all agents
  • Type safety with TypeScript throughout

Backend Agents

  • Multi-language support (Python, Go, Java, Node.js, Ruby, Rust)
  • Framework specialists for FastAPI, Spring Boot, NestJS, Rails
  • Security agents covering authentication, authorization, encryption
  • Database specialists for SQL and NoSQL
  • Language-specific best practices and idioms
  • Production-ready code patterns

.NET Agents

  • Specialized security agents for DevSecOps and compliance
  • Performance optimization agent for profiling and optimization
  • Comprehensive documentation agent for XML docs and APIs
  • Organized by domain for easy discovery

Flutter Agents

  • Feature planner that mandates reference project consultation
  • Layer-specific agents following Clean Architecture
  • Strict validation rules (only in UseCases)
  • Quality agent with Definition of Done
  • Organized by Clean Architecture layers for proper workflow

📞 Support

For issues, questions, or suggestions:

  • Open an issue in the repository
  • Reference the specific agent by name
  • Include context and use case

Model: Claude Sonnet 4.5 (claude-sonnet-4-5-20250929)

About

No description, website, or topics provided.

Resources

Readme

License

MIT license
Activity

Stars

21 stars

Watchers

0 watching

Forks

1 fork
Report repository

Releases

No releases published

Packages

No packages published