---
applyTo: "**"
---

# Your Project Name - GitHub Copilot Instructions

## Technology Stack
- **Backend Framework**: Node.js/Express, .NET Core, Python/Django, etc.
- **Frontend Framework**: React, Vue.js, Angular, etc.
- **Database**: PostgreSQL, MongoDB, MySQL, etc.
- **Testing Framework**: Jest, xUnit, PyTest, etc.
- **Infrastructure**: Docker, Kubernetes, AWS/Azure/GCP

## Coding Standards
### Naming Conventions
- **PascalCase**: Classes, interfaces, enums
- **camelCase**: Variables, functions, methods
- **SCREAMING_SNAKE_CASE**: Constants
- **kebab-case**: File names, CSS classes

### Architecture Patterns
- Use dependency injection for service management
- Implement structured logging throughout the application
- Follow repository pattern for data access
- Use async/await for asynchronous operations
- Implement proper error handling and validation

## Common Patterns to Follow
### Error Handling Template
```javascript
// JavaScript/Node.js example
try {
    logger.info('Processing request', { userId, action });
    
    const result = await service.processRequest(data);
    
    return {
        success: true,
        data: result,
        message: 'Request processed successfully'
    };
} catch (error) {
    logger.error('Request processing failed', { error: error.message, userId });
    
    if (error instanceof ValidationError) {
        return {
            success: false,
            error: 'Invalid input',
            details: error.details
        };
    }
    
    throw error; // Re-throw unexpected errors
}

{
    "success": boolean,
    "data": any,
    "message": string,
    "errors": array,
    "meta": {
        "timestamp": "ISO 8601 date",
        "version": "API version"
    }
}

### Real Example: Modern Web Application Project

Here's how to implement instruction files for different types of projects:

#### For a Node.js/React Full-Stack Application:
```markdown
## Application-Specific Guidelines

#### API Development
- Use Express.js with TypeScript for type safety
- Implement JWT-based authentication
- Use Helmet.js for security headers
- Apply rate limiting to prevent abuse
- Follow RESTful API design principles

#### Frontend Development
- Use React with TypeScript and functional components
- Implement state management with Context API or Redux Toolkit
- Use React Query for server state management
- Follow component composition patterns
- Implement proper error boundaries

#### Database Integration
- Use Prisma ORM for type-safe database operations
- Implement database migrations for schema changes
- Use connection pooling for performance
- Apply database indexing for frequently queried fields

## Framework-Specific Guidelines

#### Django Best Practices
- Use class-based views for complex logic
- Implement Django REST Framework for APIs
- Use Django's built-in authentication system
- Apply database migrations properly
- Follow Django's security recommendations

#### Code Organization
- Keep views thin, models fat
- Use serializers for API data validation
- Implement custom managers for complex queries
- Use Django's caching framework
- Apply proper logging throughout the application

---
mode: agent
tools: ['codebase', 'githubRepo']
description: Generate API endpoints following project patterns
---

# API Endpoint Generator

You are an expert backend developer specializing in creating robust, scalable API endpoints.

## Context
Using #codebase, analyze the existing API patterns and create new endpoints that follow the established architecture.

## Requirements
1. **Endpoint Structure**:
   - Follow RESTful design principles
   - Implement proper HTTP status codes
   - Include comprehensive input validation
   - Apply consistent response formatting

2. **Error Handling**:
   - Validate all input parameters
   - Return meaningful error messages
   - Log errors with appropriate context
   - Handle edge cases gracefully

3. **Security**:
   - Implement proper authentication/authorization
   - Validate and sanitize all inputs
   - Apply rate limiting where appropriate
   - Follow security best practices

4. **Performance**:
   - Use efficient database queries
   - Implement caching where beneficial
   - Consider pagination for large datasets
   - Optimize for scalability

## Example Implementation
Generate an endpoint that:
- Accepts HTTP requests with proper validation
- Implements business logic following established service patterns
- Returns properly formatted JSON responses
- Includes comprehensive error handling
- Follows established logging and monitoring patterns

When creating new endpoints, ensure they integrate seamlessly with existing codebase patterns from #codebase.

---
mode: agent
tools: ['codebase', 'githubRepo']
description: Generate API endpoints following project patterns
---

---
mode: agent
tools: ['codebase']
description: Generate unit, integration, and end-to-end tests
---

---
mode: ask
tools: ['selection', 'problems']
description: Perform thorough code review focusing on quality and standards
---

---
mode: ask
tools: ['codebase', 'selection']
description: Analyze code for security vulnerabilities and compliance
---

---
mode: edit
tools: ['selection', 'codebase']
description: Refactor code for better performance, readability, and maintainability
---

---
mode: agent
tools: ['codebase', 'selection']
description: Generate comprehensive documentation for code and APIs
---

---
mode: agent
tools: ['codebase']
description: Generate database schemas, migrations, and queries
---

---
mode: ask
tools: ['problems', 'selection', 'terminalSelection']
description: Analyze and solve bugs, errors, and performance issues
---

# 1. Created instruction file
.github/copilot-instructions.md

# 2. Built prompt library
.github/prompts/
├── api-endpoint.prompt.md
├── authentication.prompt.md
├── test-generation.prompt.md
├── database-schema.prompt.md
├── code-review.prompt.md
├── security-review.prompt.md
├── debug-troubleshoot.prompt.md
└── README.md

#prompt:api-endpoint

Create a new REST API endpoint for user profile management that:
- Handles CRUD operations for user profiles
- Implements proper authentication middleware
- Validates input data comprehensively
- Returns consistent JSON responses
- Includes proper error handling

// routes/userProfile.js
const express = require('express');
const { body, validationResult } = require('express-validator');
const authMiddleware = require('../middleware/auth');
const UserService = require('../services/UserService');
const logger = require('../utils/logger');

const router = express.Router();

/**
 * @route   GET /api/users/profile
 * @desc    Get user profile
 * @access  Private
 */
router.get('/profile', authMiddleware, async (req, res) => {
    try {
        logger.info('Fetching user profile', { userId: req.user.id });
        
        const profile = await UserService.getProfile(req.user.id);
        
        return res.json({
            success: true,
            data: profile,
            message: 'Profile retrieved successfully'
        });
    } catch (error) {
        logger.error('Profile fetch failed', { 
            error: error.message, 
            userId: req.user.id 
        });
        
        return res.status(500).json({
            success: false,
            error: 'Internal server error',
            message: 'Failed to retrieve profile'
        });
    }
});

/**
 * @route   PUT /api/users/profile
 * @desc    Update user profile
 * @access  Private
 */
router.put('/profile', [
    authMiddleware,
    body('firstName').trim().isLength({ min: 2, max: 50 }),
    body('lastName').trim().isLength({ min: 2, max: 50 }),
    body('email').isEmail().normalizeEmail(),
    body('phone').optional().isMobilePhone()
], async (req, res) => {
    try {
        const errors = validationResult(req);
        if (!errors.isEmpty()) {
            return res.status(400).json({
                success: false,
                error: 'Validation failed',
                details: errors.array()
            });
        }
        
        logger.info('Updating user profile', { userId: req.user.id });
        
        const updatedProfile = await UserService.updateProfile(
            req.user.id, 
            req.body
        );
        
        return res.json({
            success: true,
            data: updatedProfile,
            message: 'Profile updated successfully'
        });
    } catch (error) {
        logger.error('Profile update failed', { 
            error: error.message, 
            userId: req.user.id 
        });
        
        if (error.name === 'ValidationError') {
            return res.status(400).json({
                success: false,
                error: 'Invalid input data',
                details: error.details
            });
        }
        
        return res.status(500).json({
            success: false,
            error: 'Internal server error',
            message: 'Failed to update profile'
        });
    }
});

module.exports = router;

#prompt:test-generation

Create unit and integration tests for the user profile API covering:
- Valid CRUD operations with proper authentication
- Input validation edge cases
- Error scenarios and proper error responses
- Authorization checks and security boundaries

#prompt:security-review

Review the user profile API for:
- Authentication and authorization vulnerabilities
- Input validation and sanitization gaps
- Potential data leakage in error messages
- Rate limiting and abuse prevention needs

# Layer 1: High-level context
"Using #codebase, understand our Azure Functions architecture"

# Layer 2: Specific context
"Focus on #file:Services/ProxyIdService.cs to understand our ID generation patterns"

# Layer 3: Precise context
"Using #selection, modify this function to handle the new validation requirements"

# Initial request
"Create a new service following our established patterns"

# Follow-up (retains context)
"Now add comprehensive error handling to the service you just created"

# Extension (builds on previous work)
"Add unit tests that cover all the error scenarios we just implemented"

# Use agent mode for creation
@workspace Create a new API endpoint for user management

# Use edit mode for refinement  
@workspace /edit Add input validation to the endpoint

# Use ask mode for verification
@workspace /ask Does this implementation follow our security guidelines?

# Iteration 1: Basic functionality
"Create a simple CRUD service"

# Iteration 2: Add robustness
"Enhance the service with proper error handling and logging"

# Iteration 3: Optimize performance
"Add caching and connection pooling to improve performance"

# Iteration 4: Security hardening
"Review and enhance security aspects of the implementation"

**Before Copilot:**
- Feature completion: 2-3 weeks
- Bug fix cycles: 3-5 days
- Code review iterations: 4-6 rounds

**After Strategic Copilot Implementation:**
- Feature completion: 3-5 days
- Bug fix cycles: 4-8 hours
- Code review iterations: 1-2 rounds

## Prompt Performance Metrics
- **api-endpoint.prompt.md**: 95% success rate, saves 4 hours per endpoint
- **test-generation.prompt.md**: 88% success rate, saves 6 hours per test suite
- **code-review.prompt.md**: 92% success rate, reduces review time by 60%
- **security-review.prompt.md**: 85% success rate, identifies 90% of common vulnerabilities

## Common Issues and Fixes
- **Issue**: Generated code uses inconsistent error handling
- **Fix**: Added explicit error handling templates in instructions
- **Result**: 100% compliance with error handling standards

- **Issue**: Tests don't cover edge cases consistently
- **Fix**: Added specific test case requirements to instructions
- **Result**: 95% increase in edge case coverage

## Context Variable Effectiveness
- **#codebase**: Essential for architectural consistency
- **#file**: Crucial for pattern matching
- **#selection**: Perfect for targeted modifications
- **#problems**: Invaluable for debugging sessions

"Create a REST API"

"Using #codebase patterns, create a REST API for user management that follows our established authentication patterns, uses our standard error handling approach, and integrates with our existing database service shown in #file:services/DatabaseService.js"

"Using #codebase #file:Service1.cs #file:Service2.cs #file:Service3.cs #selection create a new service"

"Using #codebase, create a new service that follows the patterns established in our existing services"

# First iteration
"Create a basic validation service"

# Second iteration  
"Enhance the validation service with comprehensive error handling"

# Third iteration
"Add unit tests covering all validation scenarios"

"Design a microservices architecture for e-commerce platform with 100k users"
→ Complete architecture with services, databases, deployment patterns

Working on user service → "Should I generate the corresponding test suite?"

"Generate authentication service using our organization's established patterns"
→ Consistent with all team projects across different technology stacks