# Project Overview
**Tech Stack:** .NET 9, React 18, Node.js 20, Azure Functions, CosmosDB
**Architecture:** Microservices with Clean Architecture, CQRS pattern
**Deployment:** Azure DevOps, Container Apps, App Service

# Development Standards
- Use dependency injection consistently
- Follow SOLID principles, especially in .NET APIs
- React components should be functional with hooks
- TypeScript strict mode enabled
- Azure Function HTTP triggers follow REST conventions

# Common Commands
- `dotnet run --project src/Api` - Start API locally
- `npm run dev` - React development server
- `az functionapp create` - Deploy functions
- `docker-compose up -d` - Local services

# Architecture Decisions
- Authentication via Azure AD B2C
- State management with Zustand (not Redux)
- Database migrations via EF Core
- Error handling with Result pattern, no exceptions for business logic

src/
├── .claude/
│   ├── commands/           # Custom slash commands
│   └── project-context.md  # Additional context
├── api/                   # .NET API
├── web/                   # React frontend
├── functions/             # Azure Functions
├── shared/                # Common libraries
└── docs/                  # Architecture decisions

# Terminal 1: Implementation
claude -p "Implement user authentication middleware for our .NET API.
Follow the patterns in claude.md. Focus on Azure AD integration."

# Terminal 2: Review
claude -p "Review the authentication code in /src/api/middleware/.
Check for security vulnerabilities and suggest improvements."

# Agent 1: Write comprehensive tests
claude -p "Create unit tests for the UserService class. Cover edge cases for Azure AD token validation."

# Agent 2: Implementation
claude -p "Implement UserService to make all these tests pass. Use proper dependency injection."

# All running simultaneously
claude -p "Optimize the React performance for the dashboard component" &
claude -p "Add logging to Azure Functions using ILogger" &
claude -p "Create CosmosDB migration script for new user fields" &

# In your Azure DevOps pipeline
claude -p "Analyze this pull request for security issues in our .NET API" --json |
jq '.security_findings' |
az devops work-item create --fields

claude -p "Generate ARM template for staging environment based on production config.
Reduce instance counts by 50% and use Basic tier services." --json

"Review our Azure Function bindings. Are we following best practices for CosmosDB integration?
Suggest performance optimizations for high-throughput scenarios."

"Generate appsettings.json configurations for Development, Staging, and Production.
Include Azure Key Vault integration and proper connection string management."

"Create a TypeScript React component for user profile editing.
Include form validation with react-hook-form,
error boundaries, and loading states.
Follow our existing design system patterns."

"Refactor this Redux store to use Zustand.
Maintain the same API surface but improve performance for our dashboard widgets."

"Build a Node.js Express API with TypeScript for our document processing service.
Include Azure Blob Storage integration, proper error handling, and OpenAPI documentation."

"Here's our UserService interface and the failing test.
The issue is with password validation logic.
Focus on the ValidatePasswordComplexity method."

# Analyze Performance Issues

Please analyze the attached profiling data from Azure Application Insights.
Focus on:
- Database query performance
- Azure Function cold starts
- React rendering bottlenecks

Provide specific recommendations with code examples.

Parameters: $ARGUMENTS (service name or component)

# Generate Deployment Scripts

Create Azure DevOps YAML pipeline for deploying $ARGUMENTS to Azure.
Include:
- Infrastructure as Code (ARM/Bicep)
- Security scanning
- Automated testing
- Blue-green deployment strategy

# Before PR submission
claude -p "Review this feature implementation. Check for:
1. Security vulnerabilities
2. Performance implications
3. Adherence to our coding standards
4. Missing test coverage"

"Based on this Azure DevOps user story, create:
1. API endpoint specification
2. Database schema changes
3. React component wireframe
4. Unit test outline
5. Deployment checklist"

"Analyze this production error from Azure Application Insights.
Stack trace: [paste stack trace]
Recent deployments: [paste recent changes]
Provide root cause analysis and fix recommendations."

"Generate a new microservice template for our architecture:
- .NET 8 Web API
- Azure Service Bus integration
- CosmosDB repository pattern
- Health checks and observability
- Helm chart for Kubernetes deployment"

markdown
# Architecture Review

Analyze the current project structure and provide recommendations for:

1.**Code Organization**: Review folder structure, separation of concerns, and module boundaries
2.**Dependency Management**: Check for circular dependencies, tight coupling issues
3.**Design Patterns**: Evaluate current patterns vs. best practices for our tech stack
4.**Scalability**: Identify potential bottlenecks and architectural improvements
5.**Security**: Review authentication, authorization, and data protection patterns

Focus on: $ARGUMENTS (specific area: api, frontend, database, infrastructure)

**Tech Stack Context:**
- Backend: .NET 8, Azure Functions, Node.js
- Frontend: React 18, TypeScript
- Database: CosmosDB, Azure SQL
- Infrastructure: Azure Container Apps, App Service

Provide specific, actionable recommendations with code examples where applicable.

markdown
# Project Health Check

Perform a comprehensive health analysis of the codebase:

**Code Quality Metrics:**
- Identify code smells and technical debt
- Check for consistent naming conventions
- Review error handling patterns
- Analyze test coverage gaps

**Performance Analysis:**
- Database query optimization opportunities
- Frontend bundle size and loading performance
- Azure Function cold start optimization
- Memory usage patterns

**Maintainability Review:**
- Documentation completeness
- Code complexity analysis
- Refactoring opportunities
- Dependency updates needed

**Security Assessment:**
- Vulnerability scanning results
- Authentication/authorization gaps
- Data validation issues
- Azure security best practices compliance

Target Area: $ARGUMENTS (all, backend, frontend, infrastructure)

Generate a prioritized action plan with effort estimates.

markdown
# Feature Scaffolding

Generate complete feature implementation scaffolding for: $ARGUMENTS

Create the following structure:

**Backend (.NET API):**
- Controller with proper HTTP verbs and status codes
- Service layer with business logic
- Repository pattern with Entity Framework
- DTOs and AutoMapper configurations
- Unit tests with xUnit and Moq
- Integration tests for API endpoints

**Frontend (React):**
- Feature components with TypeScript interfaces
- Custom hooks for data fetching and state management
- Error boundaries and loading states
- Unit tests with Jest and React Testing Library
- Storybook stories for component documentation

**Infrastructure:**
- Azure Function bindings (if applicable)
- CosmosDB/Azure SQL schema changes
- ARM template updates
- DevOps pipeline modifications

**Standards to Follow:**
- Clean Architecture principles
- SOLID design patterns
- Async/await throughout
- Proper error handling with Result pattern
- Accessibility compliance (WCAG 2.1)

Include implementation notes and potential gotchas.

markdown
# Bug Investigation & Resolution

Investigate and resolve the issue: $ARGUMENTS

**Investigation Steps:**
1.**Reproduce the Problem**: Create minimal reproduction steps
2.**Log Analysis**: Review Azure Application Insights, Function logs, and browser console
3.**Code Analysis**: Examine relevant code paths and recent changes
4.**Dependency Check**: Verify third-party library versions and Azure service status

**Root Cause Analysis:**
- Timeline of when the issue started
- Environmental factors (dev/staging/prod differences)
- Related code changes in recent deployments
- Database query performance metrics
- Azure service health status

**Resolution Strategy:**
- Immediate hotfix recommendations
- Long-term architectural improvements
- Testing strategy to prevent regression
- Monitoring and alerting enhancements

**Deliverables:**
- Fix implementation with explanation
- Unit/integration tests for the fix
- Post-mortem summary with prevention strategies
- Updated documentation or runbooks

Include Azure-specific debugging techniques and performance optimization suggestions.

markdown
# Comprehensive Code Review

Perform detailed code review for: $ARGUMENTS (file path or feature area)

**Review Criteria:****Functionality:**
- Logic correctness and edge case handling
- Business requirements compliance
- Error handling and resilience patterns

**Code Quality:**
- SOLID principles adherence
- Clean Code practices
- Consistent naming and formatting
- Appropriate abstraction levels

**Performance:**
- Algorithm efficiency
- Database query optimization
- Memory usage patterns
- Azure service usage optimization

**Security:**
- Input validation and sanitization
- Authentication and authorization
- Data protection and encryption
- OWASP Top 10 compliance

**Testing:**
- Test coverage adequacy
- Test quality and maintainability
- Integration test scenarios
- Performance test considerations

**Standards Compliance:**
- .NET coding standards
- React/TypeScript best practices
- Azure development guidelines
- Team-specific conventions

Provide specific suggestions with code examples and priority levels (Critical, High, Medium, Low).

markdown
# Refactoring Strategy

Create a comprehensive refactoring plan for: $ARGUMENTS

**Current State Analysis:**
- Code complexity metrics
- Technical debt assessment
- Performance bottlenecks
- Maintainability issues

**Refactoring Goals:**
- Improved code organization
- Enhanced performance
- Better testability
- Reduced technical debt

**Implementation Strategy:**
1.**Phase 1 - Foundation**: Critical structural improvements
2.**Phase 2 - Optimization**: Performance and efficiency gains
3.**Phase 3 - Enhancement**: Developer experience improvements

**Risk Assessment:**
- Breaking changes impact
- Deployment coordination requirements
- Testing strategy for regression prevention
- Rollback procedures

**Success Metrics:**
- Code complexity reduction targets
- Performance improvement goals
- Test coverage improvements
- Developer productivity gains

**Timeline & Resources:**
- Effort estimation per phase
- Resource allocation requirements
- Dependencies and blockers
- Milestone definitions

Include specific refactoring patterns for .NET, React, and Azure services.

markdown
# Azure Infrastructure Optimization

Analyze and optimize Azure resources for: $ARGUMENTS

**Cost Optimization:**
- Right-sizing recommendations for App Services, Functions, and databases
- Reserved instance opportunities
- Unused resource identification
- Storage tier optimization strategies

**Performance Optimization:**
- Application Insights performance analysis
- Database query performance tuning
- CDN and caching strategies
- Load balancing and scaling configurations

**Security Hardening:**
- Azure Security Center recommendations
- Network security group configurations
- Key Vault integration improvements
- Managed identity implementations

**Reliability Improvements:**
- High availability configurations
- Disaster recovery planning
- Monitoring and alerting setup
- SLA compliance strategies

**DevOps Integration:**
- Infrastructure as Code improvements
- CI/CD pipeline optimizations
- Environment promotion strategies
- Automated testing integration

Provide specific Azure CLI commands, ARM/Bicep templates, and configuration examples.

markdown
# Deployment Strategy

Create deployment plan for: $ARGUMENTS

**Pre-Deployment Checklist:**
- Code review completion
- Test coverage verification
- Performance impact assessment
- Security vulnerability scanning
- Database migration scripts validation

**Deployment Strategy:**
- Blue-green vs. rolling deployment decision
- Feature flag configurations
- Database migration coordination
- Static asset deployment (CDN updates)
- Third-party service integrations

**Azure DevOps Pipeline:**
- Build pipeline configuration
- Release pipeline stages
- Approval gates and sign-offs
- Automated testing integration
- Rollback procedures

**Monitoring & Validation:**
- Health check endpoints
- Performance monitoring setup
- Error tracking configuration
- User acceptance testing plan
- Business metric validation

**Post-Deployment:**
- Performance monitoring review
- Error rate analysis
- User feedback collection
- Technical debt assessment
- Documentation updates

Include environment-specific configurations and Azure service dependencies.

markdown
# React Component Audit

Analyze React components in: $ARGUMENTS

**Performance Analysis:**
- Unnecessary re-renders identification
- Memo optimization opportunities
- Bundle size impact assessment
- Lazy loading implementation
- Virtual scrolling needs

**Code Quality Review:**
- Hook usage best practices
- State management patterns
- Component composition vs. inheritance
- TypeScript type safety
- Accessibility compliance

**Testing Strategy:**
- Unit test coverage gaps
- Integration test scenarios
- Visual regression test needs
- Performance test requirements
- End-to-end test coverage

**Standards Compliance:**
- React 18 best practices
- TypeScript strict mode compliance
- ESLint/Prettier configuration
- Design system adherence
- Responsive design implementation

**Optimization Recommendations:**
- Code splitting opportunities
- State management improvements
- Performance optimization strategies
- User experience enhancements
- Error boundary implementations

Provide specific refactoring examples and migration strategies.

markdown
# API Design Review

Review and optimize API design for: $ARGUMENTS

**RESTful Design:**
- HTTP verb usage appropriateness
- Resource modeling accuracy
- URL structure consistency
- Status code compliance
- Content negotiation support

**Performance Optimization:**
- Query optimization opportunities
- Caching strategy implementation
- Pagination best practices
- Rate limiting configuration
- Connection pooling setup

**Security Implementation:**
- Authentication mechanisms
- Authorization granularity
- Input validation strategies
- CORS configuration
- API versioning strategy

**Documentation & Testing:**
- OpenAPI/Swagger completeness
- Postman collection accuracy
- Integration test coverage
- Performance test scenarios
- Error handling documentation

**Azure Integration:**
- Application Insights integration
- Azure API Management setup
- Function binding optimization
- Cosmos DB query efficiency
- Service Bus integration patterns

Provide specific implementation examples and Azure configuration snippets.