Basics and Best Practices of Prompt Engineering with GitHub Copilot

Table of Contents

• What is Prompt Engineering?
• Core Principles of Prompt Engineering
• Best Practices
• Prompt Patterns
• Common Mistakes to Avoid
• Advanced Techniques
• Language-Specific Considerations
• Exam Key Points

What is Prompt Engineering?

Prompt engineering is the art and science of crafting effective prompts (instructions or comments) that guide AI systems like GitHub Copilot to generate the desired code output. Effective prompts transform your natural language comments into precise, actionable code.

Key Concept: Prompt engineering is essential because GitHub Copilot can't read your mind—you need to provide clear, specific instructions to get the best results.

Core Principles of Prompt Engineering

1. Be Specific

Vague prompts lead to generic suggestions. Specific prompts yield targeted code.

Bad: "Write a function"

Good: "Write a function that calculates the factorial of a positive integer using recursion"

2. Provide Context

Include relevant information about what you're trying to accomplish.

Bad: "Sort this"

Good: "Sort this array of user objects by their registration date in descending order"

3. Use Examples

Show Copilot what you want by providing examples.

// Example: convert "hello world" to "Hello World"
// Write a function to capitalize first letter of each word

4. Specify Requirements

Clearly state constraints, edge cases, and requirements.

Example: "Write a function that validates email addresses. Must handle null/undefined inputs and return false for invalid formats."

Best Practices

1. Start with Comments

Write descriptive comments before code to guide Copilot:

// Calculate the total price including tax
// Tax rate is 8.5% and applies to items over $100
function calculateTotal(items) {
  // Copilot will suggest implementation
}

2. Use Descriptive Names

Function and variable names provide context:

• Use clear, descriptive function names
• Name variables to indicate their purpose
• Follow naming conventions for your language

3. Break Down Complex Tasks

Divide complex requirements into smaller, manageable prompts:

• Start with high-level description
• Add details incrementally
• Refine suggestions iteratively

4. Include Edge Cases

Mention how to handle edge cases:

"Handle empty arrays, null values, and negative numbers"

5. Specify Output Format

Tell Copilot what format you want:

• Return type (object, array, string, etc.)
• Data structure format
• Error handling approach

Prompt Patterns

Pattern 1: Function Description

// Function to find the maximum value in an array
function findMax(arr) { }

Pattern 2: Step-by-Step Instructions

// 1. Filter users by age > 18
// 2. Sort by name alphabetically
// 3. Return first 10 results
function getAdultUsers(users) { }

Pattern 3: Example-Based

// Convert: "hello world" -> "Hello World"
// Convert: "JAVA SCRIPT" -> "Java Script"
function capitalizeWords(str) { }

Pattern 4: Constraint-Based

// Validate password: min 8 chars, 1 uppercase, 1 number
// Return true if valid, false otherwise
function validatePassword(password) { }

Common Mistakes to Avoid

1. Too Vague

Avoid: "Make it work" → Use: "Implement error handling for network failures"

2. Missing Context

Avoid: "Sort this" → Use: "Sort this array of objects by the 'price' property in ascending order"

3. Assuming Knowledge

Don't assume Copilot knows your project structure—provide necessary context

4. Single Shot Prompts

Break complex tasks into smaller prompts for better results

Advanced Techniques

1. Chain of Thought

Break down reasoning steps:

// Step 1: Parse the input string
// Step 2: Extract numbers and operators
// Step 3: Evaluate the expression
// Step 4: Return the result
function evaluateExpression(expr) { }

2. Few-Shot Learning

Provide examples of desired behavior:

// Format: "John Doe" -> "J. Doe"
// Format: "Jane Smith" -> "J. Smith"
function formatName(name) { }

3. Iterative Refinement

Start broad, then refine:

1. Write initial prompt
2. Review suggestion
3. Add more specific requirements
4. Refine until satisfied

Language-Specific Considerations

Popular Languages

Copilot works best with popular languages (Python, JavaScript, Java, etc.) because:

• More training data available
• Better pattern recognition
• More accurate suggestions

Less Popular Languages

For less common languages:

• Provide more detailed prompts
• Include language-specific syntax hints
• Use examples from your codebase
• Consider using Copilot Chat for complex requests

Exam Key Points

• Prompt engineering is essential—Copilot can't read your mind
• Be specific, provide context, use examples
• Start with descriptive comments before code
• Use clear, descriptive function and variable names
• Break complex tasks into smaller prompts
• Specify requirements, constraints, and edge cases
• Iterative refinement improves results
• Popular languages get better suggestions due to more training data
• Avoid vague prompts—always be specific