Elevating Code Quality with Custom GitHub Copilot Instructions

@Component({
  selector: 'app-user-list',
  templateUrl: './user-list.component.html',
  styleUrls: ['./user-list.component.css']
})
export class UserListComponent implements OnInit {
  users: User[] = [];
  
  constructor(private userService: UserService) { }
  
  ngOnInit(): void {
    this.userService.getUsers().subscribe(users => {
      this.users = users;
    });
  }
}

@Component({
  selector: 'app-user-list',
  standalone: true,
  imports: [CommonModule],
  templateUrl: './user-list.component.html',
  styleUrls: ['./user-list.component.css']
})
export class UserListComponent {
  private userService = inject(UserService);
  
  users = signal<User[]>([]);
  loading = signal<boolean>(false);
  
  constructor() {
    this.loadUsers();
  }
  
  private loadUsers(): void {
    this.loading.set(true);
    this.userService.getUsers().subscribe({
      next: (data) => {
        this.users.set(data);
        this.loading.set(false);
      },
      error: (err) => {
        console.error('Failed to load users', err);
        this.loading.set(false);
      }
    });
  }
}

Your goal is to generate a new React form component.

Ask for the form name and fields if not provided.

Requirements for the form:
- Use form design system components: [design-system/Form.md](../docs/design-system/Form.md)
- Use `react-hook-form` for form state management:
  - Always define TypeScript types for your form data
  - Prefer *uncontrolled* components using register
  - Use `defaultValues` to prevent unnecessary rerenders
- Use `yup` for validation:
  - Create reusable validation schemas in separate files
  - Use TypeScript types to ensure type safety
  - Customize UX-friendly validation rules

  "github.copilot.chat.codeGeneration.instructions": [
  {
    "text": "Always add a comment: 'Generated by Copilot'."
  },
  {
    "text": "In TypeScript always use underscore for private field names."
  },
  {
    "file": "angular-instructions.md" // import instructions from file `angular-instructions.md`
  },
  {
    "file": "dotnet-instructions.md" // import instructions from file `dotnet-instructions.md`
  }
],

/tests #file:src/services/user.service.ts
Generate comprehensive unit tests for the UserService class including edge cases and error scenarios.

/explain #file:src/components/user-profile.component.ts
Explain how this Angular component uses signals for state management and the benefits of this approach.

/fix 
The authentication is failing intermittently. Here's the error: [paste error message]

# GitHub Copilot Instructions for Angular 19+

Generate code following these modern Angular 19 + best practices:

## Dependency Injection
- Always use functional injection with `inject()` instead of constructor-based injection
- Example: `private userService = inject(UserService);` instead of constructor injection
- Apply this for services, tokens, and parent component references

## State Management
- Use signals for component state instead of class properties
  - Example: `counter = signal<number>(0);`
- Use computed signals for derived state
  - Example: `doubleCounter = computed(() => this.counter() * 2);`
- Prefer signals over RxJS observables for component-level state

## Component Structure
- Use standalone components as the default approach
- Use the modern control flow syntax (`@if`, `@for`, etc.)
- Implement OnPush change detection strategy for better performance

## Services & HTTP
- For service calls using subscribe, use the next syntax:
  this.userService.getUsers().subscribe({
    next: (users) => this.users.set(users),
    error: (error) => this.errorMessage.set(error)
  });

## Routing & Guards
- Use functional syntax for guards and resolvers
- Example:
  export const authGuard = () => {
    const router = inject(Router);
    const authService = inject(AuthService);
    
    if (authService.isAuthenticated()) {
      return true;
    }
    
    return router.parseUrl('/login');
  };

## HTTP Interceptors
- Use functional interceptors
- Example:
  export const authInterceptor: HttpInterceptorFn = (req, next) => {
    const authService = inject(AuthService);
    const token = authService.getToken();
    
    if (token) {
      const authReq = req.clone({
        headers: req.headers.set('Authorization', `Bearer ${token}`)
      });
      return next(authReq);
    }
    
    return next(req);
  };

## Styling
- Use Angular Material 19 with proper theming
- Implement TailwindCSS for utility-first styling
- Ensure components support theme switching
- Apply consistent color tokens from design system

## Input/Output Handling
- Use strongly typed inputs and outputs
- Example:
  @Input({ required: true }) id!: string;
  @Output() saved = new EventEmitter<User>();

## Sample Component
import { Component, computed, signal, Input, Output, EventEmitter } from '@angular/core';
import { CommonModule } from '@angular/common';
import { ReactiveFormsModule, FormBuilder, Validators } from '@angular/forms';
import { MatButtonModule } from '@angular/material/button';
import { MatInputModule } from '@angular/material/input';
import { UserService } from './user.service';

@Component({
  selector: 'app-user-profile',
  standalone: true,
  imports: [CommonModule, ReactiveFormsModule, MatButtonModule, MatInputModule],
  template: `
    <div class="p-4 bg-surface-container rounded-lg">
      <h2 class="text-xl font-bold text-on-surface mb-4">User Profile</h2>
      
      @if (isLoading()) {
        <div class="flex justify-center">
          <mat-spinner diameter="40"></mat-spinner>
        </div>
      } @else if (user()) {
        <div class="mb-4">
          <p class="text-on-surface-variant">Username: {{user()?.username}}</p>
          <p class="text-on-surface-variant">Email: {{user()?.email}}</p>
        </div>
        
        <button mat-raised-button color="primary" class="mt-2" (click)="onEdit()">
          Edit Profile
        </button>
      } @else {
        <p class="text-error">User not found</p>
      }
    </div>
  `
})
export class UserProfileComponent {
  @Input() set userId(id: string) {
    this.loadUser(id);
  }
  @Output() editRequested = new EventEmitter<string>();
  
  private userService = inject(UserService);
  
  user = signal<User | null>(null);
  isLoading = signal<boolean>(false);
  error = signal<string | null>(null);
  
  userInitials = computed(() => {
    const u = this.user();
    return u ? `${u.firstName.charAt(0)}${u.lastName.charAt(0)}` : '';
  });
  
  private loadUser(id: string): void {
    this.isLoading.set(true);
    this.error.set(null);
    
    this.userService.getUserById(id).subscribe({
      next: (userData) => {
        this.user.set(userData);
        this.isLoading.set(false);
      },
      error: (err) => {
        this.error.set('Failed to load user');
        this.isLoading.set(false);
      }
    });
  }
  
  onEdit(): void {
    if (this.user()) {
      this.editRequested.emit(this.user()!.id);
    }
  }
}

# GitHub Copilot Instructions for .NET 8+

Generate code following these modern .NET 8+ best practices:

## C# Language Features
- Use C# 12+ features such as primary constructors, required properties, file-scoped namespaces
- Use pattern matching where appropriate
- Use nullable reference types with proper null checks
- Use records for DTOs and immutable data

## Project Architecture
- Follow Clean Architecture principles with Domain/Application/Infrastructure layers
- Use minimal APIs for simpler endpoints
- Prefer vertical slice architecture with MediatR for larger applications
- Use CQRS pattern to separate reads and writes when appropriate

## APIs and Endpoints
- For minimal APIs:
  app.MapGet("/api/products", async (IMediator mediator) => 
      await mediator.Send(new GetProductsQuery()))
      .WithName("GetProducts")
      .WithOpenApi()
      .RequireAuthorization("read:products");

- For controller-based APIs:
  [HttpGet]
  public async Task<ActionResult<IEnumerable<ProductDto>>> GetProducts(
      CancellationToken cancellationToken)
  {
      var query = new GetProductsQuery();
      var result = await _mediator.Send(query, cancellationToken);
      return Ok(result);
  }

## Dependency Injection
- Use constructor injection with required parameters:
  public class ProductService(
      IRepository<Product> repository,
      IMapper mapper,
      ILogger<ProductService> logger)
      : IProductService 
  {
      // Properties are implicitly created from constructor parameters
  }

## Entity Framework Core
- Use EF Core 8.0+ features
- Configure entities using Fluent API in separate configuration classes
- Use strongly-typed IDs when appropriate
- Use bulk operations for performance
- Use compiled queries for frequently used queries

## Error Handling
app.UseExceptionHandler(exceptionHandlerApp => 
{
    exceptionHandlerApp.Run(async context => 
    {
        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
        context.Response.ContentType = "application/problem+json";
        
        var exceptionHandlerFeature = context.Features.Get<IExceptionHandlerFeature>();
        if (exceptionHandlerFeature != null)
        {
            var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
            logger.LogError(exceptionHandlerFeature.Error, "Unhandled exception");
            
            var problemDetails = new ProblemDetails
            {
                Status = StatusCodes.Status500InternalServerError,
                Title = "An unexpected error occurred",
                Detail = exceptionHandlerFeature.Error.Message,
                Instance = context.Request.Path
            };
            
            await context.Response.WriteAsJsonAsync(problemDetails);
        }
    });
});

## Authentication & Authorization
- Use ASP.NET Core Identity or custom JWT authentication
- Implement proper role/policy-based authorization
- Use Auth0 or IdentityServer for OAuth2/OpenID Connect

## Performance Optimization
- Use Memory Cache or Distributed Cache appropriately
- Implement rate limiting for APIs
- Use output caching middleware for HTTP responses
- Use response compression
- Implement proper database indexing

## Sample Service Implementation
public class GetProductByIdHandler : IRequestHandler<GetProductByIdQuery, ProductDto?>
{
    private readonly ApplicationDbContext _dbContext;
    private readonly IMapper _mapper;
    private readonly ILogger<GetProductByIdHandler> _logger;

    public GetProductByIdHandler(
        ApplicationDbContext dbContext,
        IMapper mapper,
        ILogger<GetProductByIdHandler> logger)
    {
        _dbContext = dbContext;
        _mapper = mapper;
        _logger = logger;
    }

    public async Task<ProductDto?> Handle(
        GetProductByIdQuery request,
        CancellationToken cancellationToken)
    {
        _logger.LogInformation("Getting product with ID {ProductId}", request.Id);
        
        var product = await _dbContext.Products
            .AsNoTracking()
            .FirstOrDefaultAsync(p => p.Id == request.Id, cancellationToken);
            
        return product is null ? null : _mapper.Map<ProductDto>(product);
    }
}

## Configuration and Options Pattern
public class EmailSettings
{
    public required string SmtpServer { get; init; }
    public required int Port { get; init; }
    public required string Username { get; init; }
    public required string Password { get; init; }
    public bool EnableSsl { get; init; } = true;
}

// In Program.cs
builder.Services.Configure<EmailSettings>(
    builder.Configuration.GetSection("EmailSettings"));

// In service
public class EmailService(IOptions<EmailSettings> options)
{
    private readonly EmailSettings _settings = options.Value;
    
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        // Implementation using _settings
    }
}

## Logging
builder.Host.UseSerilog((context, services, configuration) => configuration
    .ReadFrom.Configuration(context.Configuration)
    .ReadFrom.Services(services)
    .Enrich.FromLogContext()
    .WriteTo.Console());

## Health Checks and Monitoring
builder.Services.AddHealthChecks()
    .AddDbContextCheck<ApplicationDbContext>()
    .AddCheck("Redis", new RedisHealthCheck(_connectionMultiplexer))
    .AddUrlGroup(new Uri("https://api.example.com/health"), name: "External API");