A comprehensive collection of 24+ expert agents (including FinTech & Healthcare specialists), 12 custom tools with built-in analytics and resource discovery, 5 language instructions, 5 prompts, and 5 comprehensive skills for GitHub Copilot, now powered by Specification-Driven Development (SDD).

Agent Pro provides 40+ curated resources plus SDD methodology framework to enhance your development workflow with AI-powered assistance across multiple domains including architecture, security, testing, cloud infrastructure, regulated industries (finance, healthcare), and systematic feature development. All resources are interconnected via the Related Resources feature.

• 24 Expert Agents - Specialized AI assistants accessible via @ in Copilot Chat
• 12 Custom Tools - Code analysis, test generation, documentation, performance profiling, dependency analysis, API design, 5 SpecKit SDD tools, plus resourceDiscovery
• Specification-Driven Development - Complete SDD framework with constitutional governance, templates, and validation
• Built-in Analytics - Track tool usage, success rates, and performance (privacy-respecting, local only)
• Copilot Integration - All agents appear natively in GitHub Copilot's @ menu
• 5 Language Instructions - Auto-applied coding standards for Python, TypeScript, Go, Rust, Java
• 5 Reusable Prompts - Pre-built templates for common tasks
• 5 Comprehensive Skills - Bundled capabilities with best practices
• Constitutional Framework - 8 architectural principles governing all development
• Enhanced Validation - Production-ready validation with framework version checks and security pattern detection
• Comprehensive Testing - 53 functional tests ensure production quality
• Global Storage - Agents available in all your projects

1. Install Agent Pro from the VS Code Marketplace
2. Open GitHub Copilot Chat (Ctrl+Alt+I / Cmd+Option+I)
3. Type @ to see all 24 expert agents
4. Select an agent (e.g., @PythonExpert or @FinTechExpert) and start chatting!
5. Agents automatically have access to 6 custom tools for enhanced capabilities
6. View usage statistics: Ctrl+Shift+P → "Agent Pro: Show Usage Statistics"

Open GitHub Copilot Chat and type @ to see all available agents. All agents now have access to these custom tools:

• codeAnalyzer - Analyzes code complexity, metrics, and patterns
• testGenerator - Suggests test strategies for your code
• documentationBuilder - Generates documentation templates
• performanceProfiler - Detects performance anti-patterns
• dependencyAnalyzer - Scans project dependencies (package.json, requirements.txt, go.mod, Cargo.toml)
• apiDesigner - Provides OpenAPI 3.1 specifications and REST API best practices

Example:

@python-expert analyze this code for complexity
@testing-specialist suggest tests for this function
@performance-expert profile this algorithm
@fintech-expert review this payment processing code for PCI DSS compliance
@healthcare-expert validate this FHIR resource

Prompts are reusable templates that work with specific agents:

• Code Review - Comprehensive code review checklist
• Conventional Commit - Generate semantic commit messages
• Generate README - Create comprehensive README files
• Generate Tests - Generate test suites (unit/integration/E2E)
• Refactor Code - Refactor for quality and maintainability

Instructions automatically apply to files matching patterns:

• Python (**/*.py) - PEP 8, type hints, asyncio, modern best practices
• TypeScript (**/*.ts, **/*.tsx) - TS 5.x standards, React patterns
• Go (**/*.go) - Effective Go, idioms, error handling
• Rust (**/*.rs) - Rust API Guidelines, ownership, safety patterns
• Java (**/*.java) - Modern Java 17+, records, sealed classes, streams

Skills are comprehensive, self-contained capabilities:

1. API Development - RESTful APIs, FastAPI, Express, OpenAPI
2. Database Design - PostgreSQL, schemas, normalization, optimization
3. GraphQL & Microservices - Federation 2.10, distributed patterns
4. Multi-Agent Orchestration - Agent HQ, workflow coordination
5. Testing Strategies - TDD/BDD, shift-left/right, test pyramid

All agents have access to 7 specialized tools (plus 5 SpecKit tools):

Analyzes code complexity, metrics, and patterns:

• Total lines, code lines, comment lines
• Average line length and comment ratio
• Language-specific insights

Suggests test strategies and frameworks:

• Recommends appropriate testing framework (Jest, pytest, JUnit, etc.)
• Identifies test types needed (unit, integration, edge cases)
• Analyzes code structure for testability

Generates documentation templates:

• Language-specific doc formats (JSDoc, TSDoc, docstring, JavaDoc, etc.)
• Function/method documentation structure
• Usage examples and best practices

Detects performance anti-patterns:

• Array operations in loops
• Inefficient chaining (map+filter)
• Deep clone anti-patterns
• Framework-specific optimizations

Scans and analyzes project dependencies:

• Supports: package.json (Node.js), requirements.txt (Python), go.mod (Go), Cargo.toml (Rust)
• Detects outdated packages and provides update recommendations
• Security scanning suggestions (Dependabot, Renovate, pip-audit, cargo audit)

REST API design and OpenAPI specification generator:

• OpenAPI 3.1 templates and best practices
• HTTP verb mapping and resource naming conventions
• API design patterns (pagination, filtering, sorting, HATEOAS)
• Security guidelines (OAuth 2.0, JWT, rate limiting)
• Framework-specific tool recommendations (FastAPI, Express, SpringDoc)

Discover all available Agent Pro resources:

• Lists all agents, prompts, skills, instructions, and templates
• Helps find the right resource for your task
• Shows relationships between resources

1. @graphql-expert design my API schema
2. Use codeAnalyzer tool to check complexity
3. @security-expert review authentication
4. @testing-specialist create integration tests (with testGenerator)
5. @documentation-expert generate API docs (with documentationBuilder)

1. @mobile-development-expert help me structure this React Native app
2. @design-systems-expert create component library
3. @performance-expert optimize rendering (with performanceProfiler)
4. @accessibility-expert ensure WCAG compliance

1. @data-engineering-expert design ETL pipeline
2. @cloud-architect set up infrastructure
3. @observability-sre-expert add monitoring
4. @testing-specialist create data quality tests

1. @ai-ml-engineering-expert help build RAG system
2. @python-expert optimize model code (with codeAnalyzer)
3. @platform-engineering-expert create deployment pipeline
4. @observability-sre-expert add model monitoring

Key agents now have critical content embedded inline for consistent, self-contained operation:

• TypeScript Expert: Embedded strict tsconfig requirements, naming conventions, anti-patterns to flag
• Python Expert: Embedded PEP 8 rules, type hint requirements, import ordering
• Code Reviewer: Embedded security/quality/performance checklists, severity classification
• Testing Specialist: Embedded TDD methodology, testing trophy, coverage targets
• DevOps Expert: Embedded conventional commits format, commit types, CI/CD examples
• Security Expert: Embedded OWASP Top 10 checklist, security headers, critical checks

• New agent-quickref.md - Quick reference for all 24 agents
• Shows embedded resources summary per agent
• Custom tools reference table
• Quick commands cheatsheet

• Agent Pro: Show Agent Quick Reference - View embedded resources for key agents via quick pick

• 53 functional tests (up from 45)
• Tests verify embedded content in all enhanced agents

• Complete SDD methodology framework
• Constitutional governance with 8 architectural principles
• 4 SDD templates: spec, plan, tasks, checklist
• 5 SpecKit tools accessible through Copilot Chat
• Numbered feature specifications for all agents, tools, and skills
• Integration guide for systematic agent development

• specKitConstitution - Access constitutional framework
• specKitSpecTemplate - Feature specification template
• specKitPlanTemplate - Implementation planning template
• specKitTasksTemplate - Task breakdown template
• specKitChecklist - Quality validation checklist

• resourceDiscovery - List all available agents, prompts, skills, instructions, and templates

Total: 12 custom tools (6 core + 5 SpecKit + 1 discovery)

• spec-driven.md - Complete SDD guide
• agents.md - Agent integration checklist
• Constitutional Framework - Governance principles
• Templates - SDD templates with usage guide
• Specifications - Feature specs directory

• 6 VSCode native tools for all agents
• Code analysis, test generation, documentation, performance profiling, dependency analysis, and API design
• Production-ready error handling

• 3 new instruction sets: Go, Rust, Java
• Comprehensive best practices for each language
• Auto-applied based on file type

• Tool reference validation
• Improved error messages with suggestions
• Performance warnings for tool count
• Quality checks for names and descriptions

For detailed documentation on each agent, prompt, and skill, see the index.md file.

To package this extension yourself:

# Install vsce globally
npm install -g @vscode/vsce
# Package the extension
cd /path/to/agent-pro
vsce package
# This creates agent-pro-1.0.0.vsix

Contributions are welcome. Please see CONTRIBUTING.md for guidelines.

MIT License - see LICENSE file for details.

• Repository: github.com/mdaashir/agent-pro
• Issues: github.com/mdaashir/agent-pro/issues

• VS Code: 1.90.0 or higher
• GitHub Copilot: Active subscription required
• GitHub Copilot Chat: Extension must be installed

• resources/agents-collection/ - 24 expert agent definitions
• resources/prompts-collection/ - 5 reusable prompt templates
• resources/instructions/ - 5 automatic instruction sets
• resources/skills-collection/ - 5 comprehensive skill bundles
• Global access via Copilot Chat (@agent-name)
• Installed to ~/.config/Code/User/globalStorage/mdaashir.agent-pro/ on activation