Best Practices và Tips cho GitHub Copilot

1. Nguyên tắc sử dụng hiệu quả

Nguyên tắc 1: Progress over Perfection

• Không có prompt hoàn hảo ngay lần đầu
• Thử nghiệm và điều chỉnh là bình thường
• Học từ mỗi lần sử dụng

Nguyên tắc 2: Context is King

• Càng nhiều context, kết quả càng tốt
• Mở các file liên quan
• Viết comments rõ ràng
• Sử dụng naming conventions tốt

Nguyên tắc 3: Review Everything

• Copilot là trợ lý, không phải thay thế
• Luôn đọc và hiểu code trước khi accept
• Test kỹ code được generate
• Đảm bảo code phù hợp với requirements

Nguyên tắc 4: Security First

• Không share thông tin nhạy cảm trong prompts
• Review code cho security vulnerabilities
• Không hardcode credentials
• Validate user inputs

Nguyên tắc 5: Learn and Adapt

• Quan sát cách Copilot code
• Học patterns và techniques mới
• Áp dụng vào workflow của bạn
• Chia sẻ kinh nghiệm với team

2. Best Practices theo tình huống

Khi bắt đầu project mới

✅ Nên làm:

/*
Project: E-commerce API
Tech stack: Node.js, Express, MongoDB, JWT
Architecture: MVC pattern
Features: User auth, Product management, Order processing
Coding standards: ESLint, Prettier, TypeScript strict mode
*/

// Copilot sẽ hiểu context và generate code phù hợp

❌ Không nên:

// Create API

Khi làm việc với codebase có sẵn

✅ Nên làm:

1. Mở các file liên quan (models, services, types)
2. Đọc existing code để hiểu patterns
3. Viết code mẫu để Copilot học
4. Sử dụng @workspace để hỏi về architecture

Ví dụ:

@workspace How is error handling implemented in this project?
@workspace Show me examples of API endpoints
@workspace What testing framework is being used?

Khi refactor code

✅ Nên làm:

// Refactor this function to:
// 1. Use async/await instead of callbacks
// 2. Add error handling
// 3. Extract validation logic
// 4. Add TypeScript types
// 5. Follow single responsibility principle

// Original function
function processUser(user, callback) {
    // old code
}

// Refactored version
async function processUser(user: User): Promise<ProcessResult> {
    // Copilot generates refactored code
}

Khi debug

✅ Nên làm:

@workspace This function is throwing "TypeError: Cannot read property 'name' of undefined"
Code: getUserName(user)
Help me debug and fix this issue

Copilot sẽ:

1. Phân tích error
2. Kiểm tra code
3. Đề xuất fixes (null checks, optional chaining, etc.)

Khi viết tests

✅ Nên làm:

// Test suite for UserService
// Cover: CRUD operations, error cases, edge cases
// Use: Jest, mock database calls
// Aim for: 80% coverage

describe('UserService', () => {
    // Test: Create user with valid data
    it('should create user successfully', async () => {
        // Copilot generates test
    });
    
    // Test: Create user with invalid data
    it('should throw error for invalid email', async () => {
        // Copilot generates test
    });
});

3. Tips nâng cao

Tip 1: Sử dụng Multi-line Comments

Hiệu quả hơn single-line:

/*
Function: calculateShippingCost
Input: 
  - weight (kg)
  - distance (km)
  - shippingMethod ('standard' | 'express' | 'overnight')
Output: cost in USD
Logic:
  - Base rate: $5
  - Weight: $2 per kg
  - Distance: $0.5 per km
  - Express: +50%
  - Overnight: +100%
*/
function calculateShippingCost(weight, distance, shippingMethod) {
    // Copilot generates accurate calculation
}

Tip 2: Tận dụng Type Definitions

TypeScript/JSDoc:

interface Product {
    id: string;
    name: string;
    price: number;
    category: string;
    inStock: boolean;
}

// Copilot sẽ suggest code với correct types
function filterProducts(products: Product[], category: string): Product[] {
    // Copilot knows the structure
}

Tip 3: Sử dụng Examples trong Comments

// Convert temperature from Celsius to Fahrenheit
// Examples:
//   celsiusToFahrenheit(0) => 32
//   celsiusToFahrenheit(100) => 212
//   celsiusToFahrenheit(-40) => -40
function celsiusToFahrenheit(celsius) {
    // Copilot generates: return (celsius * 9/5) + 32;
}

Tip 4: Chain Prompts cho Complex Tasks

Thay vì một prompt lớn:

// Step 1: Validate input
function validateOrderInput(order) {
    // Copilot generates validation
}

// Step 2: Calculate totals
function calculateOrderTotals(order) {
    // Copilot generates calculation
}

// Step 3: Process payment
async function processPayment(order, paymentInfo) {
    // Copilot generates payment logic
}

// Step 4: Create order
async function createOrder(order, paymentInfo) {
    const validatedOrder = validateOrderInput(order);
    const totals = calculateOrderTotals(validatedOrder);
    await processPayment(validatedOrder, paymentInfo);
    // Copilot continues...
}

Tip 5: Sử dụng Copilot cho Documentation

/**
 * Copilot can generate JSDoc comments
 * Just type /** above a function and press Enter
 */
function complexFunction(param1, param2, param3) {
    // implementation
}

// Copilot generates:
/**
 * Description of what the function does
 * @param {type} param1 - Description
 * @param {type} param2 - Description
 * @param {type} param3 - Description
 * @returns {type} Description
 */

Tip 6: Generate từ Specifications

Từ API spec:

/*
API Endpoint: POST /api/users
Request Body:
{
  "username": "string",
  "email": "string",
  "password": "string"
}
Response: 201 Created
{
  "id": "string",
  "username": "string",
  "email": "string",
  "createdAt": "datetime"
}
Errors:
- 400: Invalid input
- 409: User already exists
*/

app.post('/api/users', async (req, res) => {
    // Copilot generates complete endpoint
});

Tip 7: Sử dụng Copilot Chat cho Research

How do I implement JWT authentication in Express?
What's the difference between PUT and PATCH?
Show me best practices for error handling in Node.js
Explain the Repository pattern

Tip 8: Generate Test Data Realistically

// Generate realistic test data for e-commerce
// Include: various product types, price ranges, categories
// Make it diverse and representative
const testProducts = [
    // Copilot generates realistic data
    {
        id: 'prod_001',
        name: 'Wireless Bluetooth Headphones',
        price: 79.99,
        category: 'Electronics',
        inStock: true,
        rating: 4.5
    },
    // ... more realistic products
];

Tip 9: Optimize với Copilot

// Original slow code
function findDuplicates(arr) {
    const duplicates = [];
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
                duplicates.push(arr[i]);
            }
        }
    }
    return duplicates;
}

// Ask Copilot to optimize
// Optimize this function for better performance
// Use Set or Map for O(n) complexity
function findDuplicatesOptimized(arr) {
    // Copilot generates optimized version
}

Tip 10: Batch Operations

// Process multiple files with similar changes
// Use Copilot Edits for batch operations

// Example: Add error handling to all API calls
// Copilot can update multiple files at once

4. Workflow Best Practices

Morning Routine

1. Review Copilot suggestions từ hôm trước
   • Có patterns nào học được?
   • Có lỗi nào cần fix?
2. Update context
   • Mở files sẽ làm việc
   • Review recent changes
   • Check project documentation
3. Plan với Copilot

   @workspace What should I work on today?
   Show me open TODOs
   List incomplete features
   

During Development

1. Write comments first
   • Mô tả logic trước khi code
   • Giúp organize thoughts
   • Copilot generate tốt hơn
2. Incremental development
   • Code từng phần nhỏ
   • Test sau mỗi phần
   • Không generate quá nhiều cùng lúc
3. Review as you go
   • Đọc code ngay khi accept
   • Test immediately
   • Fix issues sớm

Code Review

1. Self-review với Copilot ``` @workspace Review this code for:
   • Security issues
   • Performance problems
   • Best practices violations
   • Potential bugs ```
2. Document changes

   // Generate commit message
   @workspace Summarize changes in this file
   

3. Update tests

   // Update tests for new functionality
   /tests for this function
   

5. Team Best Practices

Shared Guidelines

Tạo .github/copilot-instructions.md:

# Team Coding Guidelines for Copilot

## Code Style
- Use TypeScript strict mode
- Prefer functional programming
- Use async/await over promises

## Naming Conventions
- Components: PascalCase
- Functions: camelCase
- Constants: UPPER_SNAKE_CASE
- Private methods: _prefixWithUnderscore

## Error Handling
- Always use try-catch for async
- Log errors with context
- Return meaningful error messages

## Testing
- Write tests for all public APIs
- Use Jest and Testing Library
- Aim for 80% coverage
- Mock external dependencies

## Documentation
- JSDoc for all public functions
- README for each module
- Examples in documentation

Knowledge Sharing

1. Share effective prompts
   • Document prompts that work well
   • Create prompt library
   • Team training sessions
2. Review Copilot suggestions together
   • Pair programming with Copilot
   • Discuss patterns
   • Learn from each other
3. Establish standards
   • When to use Copilot
   • When to code manually
   • Review process

6. Common Pitfalls và Cách tránh

Pitfall 1: Over-reliance

❌ Vấn đề:

• Accept mọi suggestion không suy nghĩ
• Không hiểu code đang viết
• Mất kỹ năng coding

✅ Giải pháp:

• Review mọi suggestion
• Hiểu logic trước khi accept
• Code manually cho complex logic
• Sử dụng Copilot như tool, không phải crutch

Pitfall 2: Poor Context

❌ Vấn đề:

// Do something
function process(data) {
    // Copilot confused
}

✅ Giải pháp:

// Process user registration data
// Validate email, hash password, save to database
// Return user object or throw error
function processUserRegistration(userData) {
    // Copilot generates accurate code
}

Pitfall 3: Ignoring Security

❌ Vấn đề:

// Copilot might suggest:
const query = `SELECT * FROM users WHERE id = ${userId}`;
// SQL injection vulnerability!

✅ Giải pháp:

• Always review for security
• Use parameterized queries
• Validate inputs
• Follow security best practices

Pitfall 4: Not Testing

❌ Vấn đề:

• Accept code without testing
• Assume Copilot is always correct

✅ Giải pháp:

• Write tests first (TDD)
• Test generated code
• Verify edge cases
• Use /tests command

Pitfall 5: Inconsistent Style

❌ Vấn đề:

• Copilot generates different styles
• Codebase becomes messy

✅ Giải pháp:

• Use linters (ESLint, Prettier)
• Define coding standards
• Use .github/copilot-instructions.md
• Review for consistency

7. Performance Tips

Tip 1: Optimize Copilot Response Time

• Close unnecessary tabs
• Keep workspace organized
• Use .gitignore properly
• Limit file size

Tip 2: Efficient Context Management

// Instead of opening many files, use imports
import { UserType } from './types';
import { validateUser } from './validators';

// Copilot learns from imports

Tip 3: Cache Common Patterns

// Create reusable utilities
// Copilot will suggest similar patterns

// Example: API call wrapper
async function apiCall(endpoint, options) {
    // Standard error handling, logging, etc.
}

// Copilot will suggest using this pattern

8. Measuring Success

Metrics to Track

1. Development Speed
   • Time to complete features
   • Lines of code per hour
   • Bugs per feature
2. Code Quality
   • Test coverage
   • Code review comments
   • Bug reports
3. Learning
   • New patterns learned
   • Skills improved
   • Team knowledge sharing

Continuous Improvement

1. Weekly Review
   • What worked well?
   • What didn’t work?
   • How to improve?
2. Experiment
   • Try new prompting techniques
   • Test different workflows
   • Share findings
3. Adapt
   • Update guidelines
   • Refine processes
   • Train team

9. Resources và Learning

Official Resources

• GitHub Copilot Docs: https://docs.github.com/copilot
• GitHub Blog: https://github.blog
• Copilot Changelog

Community

• GitHub Discussions
• Stack Overflow
• Reddit r/github
• Twitter #GitHubCopilot

Learning Path

Week 1-2: Basics

• Install and setup
• Basic code completion
• Simple prompts

Week 3-4: Intermediate

• Copilot Chat
• Slash commands
• Better prompts

Week 5-6: Advanced

• Agent mode
• Copilot Edits
• Custom instructions

Week 7+: Mastery

• Team workflows
• Complex projects
• Teaching others

10. Checklist tổng hợp

Before Using Copilot

• Hiểu rõ requirements
• Plan approach
• Mở relevant files
• Review existing code

While Using Copilot

• Write clear prompts
• Provide context
• Review suggestions
• Test code
• Check security

After Using Copilot

• Run tests
• Review code quality
• Update documentation
• Commit with clear message
• Share learnings

Kết luận

GitHub Copilot là công cụ mạnh mẽ khi sử dụng đúng cách:

✅ Tăng productivity - Nhưng không thay thế thinking
✅ Học patterns mới - Nhưng hiểu trước khi dùng
✅ Code nhanh hơn - Nhưng quality vẫn là ưu tiên
✅ Automate repetitive tasks - Focus vào creative work
✅ Collaborate tốt hơn - Share knowledge với team

Remember:

“GitHub Copilot is your AI pair programmer, not your replacement. Use it wisely, review everything, and keep learning!” 🚀

Bài viết được viết bằng AI 🚀

About Nguyen Chung

Hi I am Nguyen Chung, an Automation Tester.

Email : ndchungict@gmail.com

Website : https://ndchungict.github.io