GitHub Copilot Prompts

50+ copy-paste Copilot techniques that actually change how fast you ship: autocomplete patterns, Copilot Chat slash commands, Agent mode workflows, TDD with Copilot, multi-file refactoring, and documentation generation. Updated for 2026 Copilot capabilities.

AutocompleteCopilot ChatAgent ModeDebuggingTest WritingRefactoringDocumentation

Why Most Developers Are Using 20% of GitHub Copilot

Most developers who use GitHub Copilot are using it as a smarter autocomplete. They accept or reject inline suggestions and occasionally ask a Chat question. That saves time. But it leaves most of Copilot's capability unused. Copilot Chat with slash commands, workspace context, and the @workspace and @terminal scopes is a categorically different tool from autocomplete. And Agent mode, which can plan and execute multi-step tasks across multiple files, is a different tool again.

The prompt techniques in this guide cover all three modes. Autocomplete prompts focus on context setup: how to structure comments, function signatures, and open files to get better inline suggestions. Chat prompts focus on slash commands and context scoping. Agent prompts focus on writing instructions that produce reliable multi-step output without hallucinating dependencies or making unintended changes.

The context quality is the single biggest variable in Copilot output quality. A developer with a well-structured copilot-instructions.md, typed function signatures, and relevant files open gets materially better suggestions than one relying on Copilot to infer everything from the current file alone. That gap compounds across a workday into hours of recovered time.

Autocomplete (inline suggestions)

VS Code, JetBrains, Vim, Neovim

Best for: boilerplate, repetitive patterns, typed functions, config files. Set context with comments and open related files in tabs. Write the first line yourself to establish the pattern.

Copilot Chat (conversational)

VS Code, GitHub.com, JetBrains

Best for: explaining code, fixing bugs, writing tests, documentation, architectural questions. Use slash commands (/fix, /tests, /doc, /explain) for structured tasks instead of freeform chat.

Agent mode (autonomous multi-step)

VS Code (2025+)

Best for: scaffolding new features, adding patterns consistently across files, refactoring with a clear spec. Write a detailed task description with acceptance criteria. Review all changes before committing.

Copilot Context Setup: The 6 Things That Actually Improve Output

1

Add a copilot-instructions.md to your repo root

Copilot reads this file and uses it as persistent system context for your project. Include: tech stack, coding standards, naming conventions, testing approach, and patterns you want Copilot to follow. This single file improves suggestion quality across your entire project without any per-prompt effort.

2

Write typed function signatures before asking for body generation

A function signature with parameter types, return type, and a JSDoc comment gives Copilot significantly more to work with than an empty function declaration. The type information alone eliminates a large class of suggestion errors, true for TypeScript, Python type hints, Go signatures, and Java method declarations.

3

Keep relevant files open in tabs

Copilot reads all open editor tabs as context. If you are writing a new API route, have your existing routes, middleware, type definitions, and error handler open. Copilot will match your existing patterns rather than inventing new ones that do not fit your codebase.

4

Use @workspace in Chat for project-level questions

The @workspace scope gives Copilot Chat access to your full project structure and file contents. Use it for questions like 'How does authentication work in @workspace?' or 'What is the pattern for error handling in @workspace?'. Without @workspace, Chat only sees your current file.

5

Write the first line of a pattern before autocomplete

For patterns Copilot may not have seen exactly in your codebase (a custom hook, a specific error class, a novel utility function), write the first substantive line yourself before letting autocomplete continue. That first line establishes the pattern, Copilot continues it much more accurately than from a blank function body.

6

Use Agent mode with explicit acceptance criteria

Agent mode instructions that fail are almost always too vague. Instead of 'add dark mode', write: 'Add dark mode support. Use CSS custom properties defined in globals.css. Create a ThemeContext that persists preference to localStorage. All existing components should read from ThemeContext.' Specific, verifiable criteria produce reliable agent output.

GitHub Copilot vs Cursor vs Windsurf: What to Use for What

In 2026, most senior developers use more than one AI coding tool. Here is an honest breakdown for the tasks developers actually spend time on.

TaskBest ToolWhy
Daily autocomplete in existing codebaseGitHub CopilotGitHub repo context, deep VS Code integration, fastest inline suggestion loop
Multi-file refactoring with a clear specCursor ComposerMore reliable multi-file agent with better planning for large structural changes
Code explanation and reviewCopilot Chat (/explain, /fix)Fastest for quick explanations; slash commands are purpose-built for review tasks
Test generation from existing functionsCopilot Chat (/tests)Excellent at pattern-matching tests to your existing test suite style
Greenfield feature scaffoldingCopilot Agent or CursorBoth handle multi-file creation well; Cursor has better iteration loop on failures
GitHub PR review and issue contextGitHub CopilotOnly Copilot can read your PR history, issues, and Actions output as context
Aggressive architecture explorationWindsurfMore willing to make large structural proposals; useful for early-stage experimentation

GitHub Copilot Prompts

Expert prompts and techniques for pair programming with GitHub's AI coding assistant. Learn to generate code faster, debug smarter, write better tests, and ship with confidence.

Code GenerationPair ProgrammingAI Coding AssistantDebuggingTestingSecurity

How to Get the Best Results from Copilot

💬

Write Descriptive Comments First

A clear comment above a function tells Copilot exactly what you want. Treat comments as your instruction layer.

🔄

Use Alt+] to See Alternatives

Copilot generates multiple suggestions. Cycle through them to find the approach that matches your intent and style.

🎯

Use Chat for Complex Tasks

Copilot Chat (Ctrl+I) is better for refactoring, explaining logic, debugging errors, and architecture questions.

Code Generation & Completion

Generate a React component that displays a list of users with filtering and sorting capabilities. Include TypeScript types and proper error handling.

Write a utility function that converts a JavaScript object to query parameters. Handle nested objects, arrays, and special characters. Include unit tests.

Create a custom React hook for managing form state with validation, error tracking, and submit handling. Include TypeScript interfaces.

Build a Node.js Express middleware that handles rate limiting, request logging, and JWT authentication. Include error handling and TypeScript types.

Generate a TypeScript class for managing a local cache with TTL expiry, max size limits, and LRU eviction policy. Include unit tests for edge cases.

Code Explanation & Documentation

Explain this algorithm step-by-step, including time and space complexity analysis. Suggest optimizations and edge cases.

Generate comprehensive JSDoc comments for this function, including parameter descriptions, return types, and usage examples.

Write detailed API documentation for this endpoint, including request/response examples, error codes, and authentication requirements.

Create a README section explaining how this module works, when to use it, configuration options, and common usage patterns with code examples.

Refactoring & Optimization

Refactor this code to use async/await instead of promise chains. Improve error handling with try-catch blocks.

Optimize this database query. Look for N+1 problems, missing indexes, and inefficient joins. Suggest index strategies.

Convert this class component to a functional React component using hooks. Migrate lifecycle methods to useEffect and extract custom hooks.

Identify performance bottlenecks in this function and rewrite it to be more efficient. Focus on reducing unnecessary re-computation, memory allocation, and iteration over large arrays.

Debugging & Problem-Solving

I'm getting this error: [paste error]. Here's the relevant code: [paste code]. What's wrong and how do I fix it?

This function is returning unexpected values in these scenarios: [describe scenarios]. Debug it and suggest edge cases I should handle.

This test is failing with: [paste test output]. Help me understand why and write the correct assertion or fix the code.

I have a race condition in this async code that causes intermittent failures. Help me identify where the issue is and suggest the correct synchronization pattern to fix it.

Architecture & Design Patterns

Design the architecture for a [feature description]. What components, services, and data flows would you use? Suggest design patterns.

How should I apply the [design pattern name] to solve this problem: [describe problem]. Show code examples and explain the benefits.

Review this component structure for [specific purpose]. Suggest improvements for maintainability, testability, and performance.

I need to refactor this monolithic module into smaller, more focused services. Suggest how to split responsibilities, define boundaries, and manage the shared state between them.

Testing & Quality Assurance

Generate unit tests for this function. Cover happy path, edge cases, error scenarios, and boundary conditions using Jest/Vitest.

Write integration tests for this API endpoint. Test success, error handling, authentication, and data validation scenarios.

Create end-to-end tests for this user flow: [describe flow]. Use Cypress or Playwright to test across different browsers and viewport sizes.

This function has zero test coverage. Generate a comprehensive test suite including mocks for external dependencies, snapshot tests for output, and parameterized tests for multiple input variations.

Git, Code Review & Collaboration

Write a clear, informative commit message for these changes: [describe changes]. Follow conventional commit format and include the why, not just the what.

Review this pull request diff for potential issues: [paste diff]. Check for logic errors, missing error handling, security concerns, and code style inconsistencies.

Write a pull request description for these changes. Include: what changed and why, how to test it, any breaking changes, and screenshots or examples if applicable.

I'm reviewing this code change from a junior developer. Write constructive, educational feedback that explains the why behind each suggestion and encourages good practices.

Security & Best Practices

Review this code for common security vulnerabilities including SQL injection, XSS, CSRF, and insecure direct object references. Show me how to fix each issue.

This function handles user-submitted input that gets stored in a database. Audit it for injection vulnerabilities, improper sanitization, and missing validation. Rewrite it securely.

Add input validation and sanitization to this API endpoint. Ensure it rejects malformed requests, validates data types and length, and never exposes internal error details to clients.

Frequently Asked Questions

Related Prompts

Don't stop here

What to read next

Hand-picked guides our readers explore right after this one.