This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Design and develop database solutions (35–40%)
--> Design and implement SQL solutions by using AI-assisted tools
--> Create and configure GitHub Copilot instruction files
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.
Introduction
GitHub Copilot is an AI-powered coding assistant that generates code, explains existing code, creates documentation, and assists with debugging. While Copilot is powerful out of the box, organizations often need the AI to follow company-specific standards instead of producing generic code.
GitHub Copilot instruction files provide persistent guidance to Copilot. Rather than repeatedly telling Copilot the same preferences during every chat session, developers can store instructions in version-controlled files inside the repository. They help ensure that AI-generated code follows an organization’s coding standards, security requirements, architectural patterns, naming conventions, and SQL development best practices. Candidates should understand not only how to create these files, but also how they influence Copilot’s responses.
Instruction files improve:
- Consistency
- Security
- Coding standards
- SQL development practices
- Documentation quality
- Team collaboration
- AI response quality
For the DP-800 exam, understand:
- What instruction files are
- Where they are stored
- What types of instructions they contain
- How they affect Copilot responses
- Best practices for SQL development
Why Use Instruction Files?
Without instruction files:
Developer:Create a stored procedure.Copilot:Creates one using SELECT * and no error handling.
Next time:
Developer:Remember to avoid SELECT *Use TRY...CATCHUse PascalCaseInclude commentsUse parameters
The developer must continually repeat instructions.
With instruction files:
Repository contains instructions.Copilot automatically follows them.
Every developer receives consistent AI assistance.
What Are GitHub Copilot Instruction Files?
Instruction files are Markdown files that contain natural-language guidance for Copilot.
They describe:
- Coding style
- Naming conventions
- Architecture
- Security practices
- SQL standards
- Documentation requirements
- Testing expectations
Instead of writing prompts repeatedly, the repository permanently stores the instructions.
Benefits
Instruction files provide:
Consistency
Every developer receives similar AI suggestions.
Faster Development
Less prompt engineering.
Developers spend less time explaining requirements.
Higher Code Quality
Instructions encourage:
- Proper formatting
- Secure coding
- Error handling
- Documentation
Better Security
Organizations can require Copilot to:
- Parameterize SQL
- Avoid dynamic SQL
- Validate input
- Follow least privilege
Team Standards
New developers immediately receive guidance that matches experienced developers.
Repository-Level Instructions
Instruction files are stored with the project.
Example:
Repository├── .github│ copilot-instructions.md│├── Database├── Procedures├── Functions└── Tables
The instructions become part of source control.
Everyone cloning the repository receives them.
What Can Instruction Files Contain?
Common guidance includes:
Coding conventions
Example
Use PascalCase for object names.Avoid abbreviations.Use descriptive variable names.
SQL Standards
Example
Never use SELECT *Always qualify object names.Always use schema prefixes.Prefer explicit column lists.
Error Handling
Example
Always wrap stored procedures inside TRY...CATCH.Log errors before rethrowing.
Documentation
Example
Document all procedures.Include parameter descriptions.Explain business rules.
Performance
Example
Avoid cursors.Prefer set-based operations.Use appropriate indexing.Avoid unnecessary temp tables.
Security
Example
Always use parameterized queries.Never concatenate SQL strings.Validate inputs.Follow least privilege.
SQL Example
Instruction:
Use schema dbo.Always include SET NOCOUNT ON.Use TRY...CATCH.Document parameters.Never use SELECT *.
Prompt:
Create a procedure to retrieve customers.
Generated procedure might include:
CREATE PROCEDURE dbo.GetCustomers( @Country NVARCHAR(50))ASBEGINSET NOCOUNT ON;BEGIN TRYSELECTCustomerID,CustomerName,CountryFROM dbo.CustomersWHERE Country=@Country;END TRYBEGIN CATCHTHROW;END CATCHEND;
The instructions influence the generated output.
SQL Development Standards Commonly Included
Organizations commonly include instructions such as:
- Use schema-qualified names
- Use explicit column lists
- Avoid SELECT *
- Use transactions appropriately
- Always parameterize SQL
- Avoid SQL injection
- Use TRY…CATCH
- Return meaningful errors
- Comment complex logic
- Format SQL consistently
Database Naming Standards
Instruction files frequently define naming conventions.
Example
Tables
SalesOrdersCustomersInvoices
Procedures
usp_GetOrdersusp_InsertCustomer
Views
vwCustomerSales
Functions
fnCalculateTax
Documentation Standards
Instructions often require:
Every procedure includes:
- Purpose
- Parameters
- Return values
- Modification history
Example
Purpose:Returns active customers.Parameters:@CountryReturns:Customer list.
Security Guidance
Instruction files often include security rules.
Examples:
Do not:
SELECT *
Do not:
EXEC(@SQL)
Do:
sp_executesql
Do:
Parameterized queries
Require:
- Least privilege
- Input validation
- Data masking awareness
- Sensitive data handling
Performance Guidance
Example instructions:
Prefer:
- Set-based operations
- Appropriate indexes
- EXISTS
- Window functions
Avoid:
- Nested cursors
- RBAR processing
- Unnecessary DISTINCT
- Scalar UDFs inside large queries
AI Prompt Consistency
Instead of writing:
Generate a procedure.Use TRY...CATCH.No SELECT *Include comments.Use PascalCase.
Simply write:
Generate a procedure.
Copilot automatically follows repository guidance.
Version Control Benefits
Instruction files are version controlled.
Benefits include:
- Change history
- Code reviews
- Branch support
- Rollback capability
- Team collaboration
Team Collaboration
Instruction files help ensure:
Developer A
↓
Developer B
↓
Developer C
↓
Copilot
↓
Consistent code
Everyone receives similar recommendations.
Best Practices
Microsoft recommends:
- Keep instructions concise.
- Focus on project-specific guidance.
- Store instruction files with the repository.
- Update instructions as standards evolve.
- Use clear, natural language.
- Include coding, security, testing, and documentation expectations.
- Review instruction files during pull requests.
- Avoid contradictory instructions.
- Combine repository instructions with task-specific prompts when necessary.
- Regularly validate that generated code still meets organizational standards.
Common Mistakes
Avoid:
❌ Extremely long instruction files
❌ Conflicting rules
❌ Outdated architecture guidance
❌ Security rules that contradict current policy
❌ Generic instructions that provide little value
❌ Forgetting to update instructions after framework changes
❌ Assuming Copilot always follows instructions perfectly without human review
DP-800 Exam Tips
Candidates should know:
- Instruction files provide persistent repository guidance.
- They improve consistency across AI-generated code.
- They are stored with the project and version controlled.
- They can define coding standards, SQL conventions, security requirements, testing expectations, and documentation guidelines.
- They reduce repetitive prompting.
- They complement, rather than replace, user prompts.
- Developers remain responsible for validating all AI-generated code.
- Well-written instruction files improve code quality and team productivity.
Summary
GitHub Copilot instruction files are an important mechanism for guiding AI-generated code within a project. By defining repository-specific coding standards, security practices, documentation requirements, and SQL development conventions, organizations can improve consistency, reduce repetitive prompting, and ensure AI-generated code better aligns with business requirements. However, instruction files do not eliminate the need for developer review. AI-generated code should always be validated for correctness, performance, maintainability, and security before deployment.
Practice Exam Questions
Question 1
A development team wants GitHub Copilot to always generate SQL stored procedures that include SET NOCOUNT ON, TRY...CATCH blocks, and schema-qualified object names. What is the best way to accomplish this?
A. Add these requirements to a GitHub Copilot instruction file stored in the repository.
B. Modify SQL Server configuration settings.
C. Configure database compatibility level.
D. Enable Query Store.
Answer: A
Explanation: Repository instruction files provide persistent guidance that GitHub Copilot automatically considers when generating code.
Question 2
What is the primary purpose of a GitHub Copilot instruction file?
A. Improve SQL Server query performance.
B. Define repository-specific guidance that influences AI-generated code.
C. Store database credentials.
D. Configure Azure SQL firewall rules.
Answer: B
Explanation: Instruction files define coding conventions, security requirements, architectural guidance, and other project-specific expectations for Copilot.
Question 3
Which instruction would most directly reduce the likelihood of SQL injection vulnerabilities in AI-generated code?
A. Use uppercase SQL keywords.
B. Always include comments.
C. Always use parameterized queries and avoid dynamic SQL string concatenation.
D. Use table aliases.
Answer: C
Explanation: Parameterized queries are a primary defense against SQL injection attacks.
Question 4
A team updates its SQL naming conventions. What is the best way to ensure GitHub Copilot follows the new standards for all developers?
A. Send an email describing the new conventions.
B. Create a shared prompt document.
C. Ask every developer to memorize the standards.
D. Update the repository’s Copilot instruction file and commit the changes.
Answer: D
Explanation: Version-controlled instruction files distribute updated guidance to everyone working with the repository.
Question 5
Which guidance is most appropriate for inclusion in a GitHub Copilot instruction file?
A. Temporary debugging notes for one developer.
B. Personal keyboard shortcuts.
C. Repository-wide SQL coding standards and documentation requirements.
D. SQL Server service account passwords.
Answer: C
Explanation: Instruction files should contain reusable project guidance, never personal settings or sensitive information.
Question 6
Why are GitHub Copilot instruction files commonly stored in source control?
A. To improve SQL Server indexing.
B. To enable versioning, collaboration, and consistent AI guidance.
C. To reduce database storage.
D. To encrypt SQL scripts.
Answer: B
Explanation: Source control ensures instruction changes are tracked, reviewed, and shared across the team.
Question 7
Which statement about GitHub Copilot instruction files is correct?
A. They eliminate the need to review AI-generated code.
B. They guarantee every generated query is optimized.
C. They replace database security policies.
D. They supplement prompts by providing persistent project-specific guidance.
Answer: D
Explanation: Instruction files enhance Copilot responses but do not replace human review or additional task-specific prompting.
Question 8
A database team wants Copilot to avoid generating SELECT * statements. Where should this requirement be documented?
A. SQL Server Agent.
B. Azure Key Vault.
C. GitHub Copilot instruction file.
D. SQL Profiler.
Answer: C
Explanation: Coding conventions such as avoiding SELECT * are ideal candidates for repository instruction files.
Question 9
Which practice improves the long-term usefulness of GitHub Copilot instruction files?
A. Adding every possible coding preference.
B. Keeping instructions concise, current, and focused on project standards.
C. Storing passwords for easier AI access.
D. Avoiding updates after the initial creation.
Answer: B
Explanation: Effective instruction files are clear, maintainable, and updated as project standards evolve.
Question 10
A developer receives SQL code from GitHub Copilot that follows all repository instruction files. What should the developer do before committing the code?
A. Commit it immediately because instruction files guarantee correctness.
B. Only verify formatting.
C. Disable Copilot.
D. Review the code for correctness, performance, security, and compliance with business requirements.
Answer: D
Explanation: AI-generated code should always undergo human review, testing, and validation, even when instruction files are used.
Go to the DP-800 Exam Prep Hub main page
The Data Community 