Master the Copilot CLI
Ecosystem

Create a full-stack TypeScript application with a React frontend (Vite), Express API backend, and PostgreSQL database. Include authentication with JWT, CRUD operations for a "tasks" resource, and proper error handling. Set up the project structure with separate client/server directories.

Create a REST API endpoint for managing user profiles. Include GET (list/detail), POST, PUT, and DELETE operations. Add input validation with Zod, proper HTTP status codes, and TypeScript types.

Create a reusable DataTable React component with TypeScript. Support sortable columns, pagination, row selection, and search filtering. Use TailwindCSS for styling. Include prop types and a usage example.

Create a Node.js CLI tool using Commander.js for managing database migrations. Include commands: create, up, down, status. Add interactive confirmation prompts for destructive operations and colored output.

Create a WebSocket server using ws library in Node.js. Implement rooms/channels, JWT authentication on connection, heartbeat/ping mechanism, graceful reconnection handling, and typed message protocols.

Refactor all callback-based functions in this file to use async/await. Preserve error handling, add proper try/catch blocks, and ensure all edge cases are covered. Maintain backward compatibility.

This file is over 500 lines. Analyze it and extract logical groups into separate modules. Create clean public interfaces (exports) for each module. Update all imports. Ensure no circular dependencies.

Refactor the payment processing code to use the Strategy pattern. Each payment method (credit card, PayPal, crypto) should be a separate strategy. Include a factory for creating strategies and maintain the existing interface.

Audit this codebase for type safety issues. Replace all `any` types with proper types. Add generics where applicable. Enable strict null checks and fix all resulting errors. Add discriminated unions for state management.

Analyze this React application for performance issues. Add React.memo, useMemo, and useCallback where beneficial. Implement code splitting with lazy/Suspense. Optimize re-renders. Add virtualization for long lists.

Run the test suite, analyze all failing tests, identify the root cause of each failure, and fix them. Explain what was wrong and why the fix works. Do not modify the test expectations unless they are clearly wrong.

Analyze this Node.js application for memory leaks. Check for: unclosed connections, event listener accumulation, large object retention, missing cleanup in intervals/timeouts, and circular references. Fix all issues found.

I'm getting a 500 Internal Server Error on POST /api/orders. Trace the request flow from the route handler through middleware, service layer, and database queries. Find the root cause and fix it.

There's a race condition causing intermittent failures in the order processing system. Analyze all concurrent operations, identify where race conditions can occur, and implement proper synchronization (locks, queues, or atomic operations).

The build is failing with TypeScript compilation errors. Analyze the build output, identify all errors, determine if they are type errors, missing dependencies, or config issues, and fix everything so the build passes.

Analyze this monolithic application. Identify bounded contexts, propose service boundaries, define API contracts between services, suggest a communication strategy (sync/async), and create a migration plan from monolith to microservices.

Design a PostgreSQL database schema for an e-commerce platform. Include tables for users, products, categories, orders, order items, payments, reviews, and inventory. Add proper foreign keys, indexes for common queries, and constraints.

Review the API design in this project. Check for RESTful conventions, consistent naming, proper HTTP methods, pagination patterns, error response formats, versioning strategy, and rate limiting. Suggest improvements.

Design an event-driven architecture for the notification system. Define event types, create event schemas, implement publisher/subscriber patterns, add dead letter queue handling, and ensure idempotent event processing.

Create a GitHub Actions CI/CD pipeline for a Node.js application. Include: lint, test (with coverage), build, security scan, Docker build, push to registry, and deploy to staging on PR merge, production on release.

Create an optimized multi-stage Dockerfile for this Node.js application. Include: build stage, production stage with minimal image, non-root user, health check, proper cache layers, .dockerignore, and security hardening.

Create Terraform configurations for deploying this application to AWS. Include: VPC, ECS Fargate cluster, RDS PostgreSQL, ElastiCache Redis, Application Load Balancer, CloudWatch monitoring, and IAM roles with least-privilege.

Set up monitoring for this application. Add structured logging with correlation IDs, health check endpoints, metrics collection (request latency, error rate, memory usage), and alerting rules for SLA breaches.

Create Kubernetes manifests for this application. Include: Deployment with rolling update, Service, Ingress with TLS, ConfigMap, Secrets, HPA for autoscaling, PodDisruptionBudget, and resource limits.

Create database migration scripts for adding a multi-tenant architecture. Add tenant_id to all tables, create row-level security policies, update indexes, and include both up and down migrations with data preservation.

Analyze the database queries in this project. Identify slow queries, add missing indexes, rewrite inefficient joins, add proper pagination, and implement query result caching where appropriate.

Create an ETL pipeline using Node.js that: extracts data from a REST API, transforms it (clean, validate, normalize), and loads it into PostgreSQL. Include error handling, retry logic, incremental processing, and logging.

Create an AI agent using the OpenAI API that can: search the web, read files, execute code, and answer questions. Implement a tool-calling loop with proper error handling, context management, and conversation history.

Create a RAG pipeline for answering questions about documentation. Include: document chunking, embedding generation, vector store (using pgvector), semantic search retrieval, prompt construction with context, and response generation.

Build a prompt template system with: variable interpolation, version tracking, A/B testing support, output validation, and logging. Include templates for common tasks (summarization, extraction, classification).

Write unit tests for all exported functions in this module. Use Vitest with TypeScript. Include: happy path, edge cases, error scenarios, boundary values, and mock external dependencies. Aim for >90% coverage.

Write E2E tests using Playwright for the critical user flows: signup, login, create order, view order history, and checkout. Include: page objects, test fixtures, visual regression checks, and CI configuration.

Write API integration tests for all endpoints. Include: test database setup with migrations, seed data fixtures, request/response validation, auth token handling, cleanup after each test, and parallel execution support.

Generate a comprehensive README.md for this project. Include: project description, features list, architecture overview, prerequisites, installation steps, configuration guide, usage examples, API reference, contributing guidelines, and license.

Generate OpenAPI 3.0 documentation for all API endpoints. Include: path descriptions, request/response schemas, error codes, authentication requirements, example payloads, and write it as an openapi.yaml file.

Create an Architecture Decision Record (ADR) for [decision]. Include: context, decision drivers, considered options with pros/cons, decision outcome, consequences, and compliance requirements.

Audit this codebase against the OWASP Top 10. Check for: injection flaws, broken authentication, sensitive data exposure, XXE, broken access control, security misconfiguration, XSS, insecure deserialization, known vulnerabilities, and insufficient logging.

Review the authentication and authorization system. Check: password hashing (bcrypt/argon2), JWT implementation (expiry, refresh, revocation), RBAC/ABAC enforcement, session management, CSRF protection, and OAuth flows.

Scan all project dependencies for known vulnerabilities. Check npm audit results, identify critical/high severity issues, and update or replace vulnerable packages. Ensure updates don't break existing functionality.

Review all user input entry points (API endpoints, form handlers, URL parameters). Add proper input validation, sanitization, and parameterized queries. Prevent SQL injection, XSS, command injection, and path traversal.