Om GitHub Copilot beter te laten leren van jouw codebase en gerichte suggesties te krijgen, kun je de volgende stappen volgen: 1. **Gebruik consistente codepatronen en standaarden** Zorg dat je in je codebase duidelijke en consistente voorbeelden biedt van jouw stijl, vooral rondom API-gebruik en functies. Bijvoorbeeld, als je bepaalde API's of patronen prefereert, gebruik ze consequent in je code. 2. **Voeg uitgebreide en relevante docstrings toe** Beschrijf duidelijk de functionaliteit, parameters en returnwaarden van je functies. Dit helpt Copilot om de context te begrijpen en suggesties te doen die passen bij jouw manier van programmeren. 3. **Gebruik commentaar en TODO's om je intenties te verduidelijken** Plaats commentaar boven complexe of belangrijke codeblokken om je intentie te verduidelijken. Bijvoorbeeld: ```python # Gebruik onze interne API voor het ophalen van gebruikersgegevens ``` Dit helpt Copilot te leren welke API's relevant zijn voor jouw project. 4. **Maak gebruik van voorbeeldcode en snippets** Voeg in je codebase korte voorbeelden toe van de API-implementaties en patronen die je wilt gebruiken. Bijvoorbeeld: ```python def get_user_data(user_id): # Vraag gegevens op via onze API response = api_client.fetch_user(user_id) return response.json() ``` 5. **Gebruik een goede projectstructuur en bestandsindeling** Organiseer je project zodanig dat gerelateerde functies en API-implementaties gegroepeerd zijn, zodat Copilot de context beter kan begrijpen. 6. **Configureer GitHub Copilot via instellingen** - Pas je Copilot-instellingen aan om suggesties te beperken tot je projectcontext. - Gebruik `# fmt: on` en `# fmt: off` om formatting consistent te houden. - Overweeg om een `.copilot.toml` bestand te gebruiken om suggestievoorkeuren te finetunen. 7. **Verfijn met gerichte prompts en code-annotaties** In je code of comments kun je expliciet aangeven welke API's of patronen je wilt gebruiken, bijvoorbeeld: ```python # Gebruik onze custom API voor dataverwerking ``` 8. **Iteratief verbeteren door feedback** Als Copilot irrelevante suggesties geeft, corrigeer en verfijn je code en commentaar. Hoe meer je de suggesties bijstuurt, hoe meer het model leert wat relevant is. Door deze gerichte aanpak en consistente invoer te gebruiken, help je Copilot om beter te leren van jouw codebase en relevante suggesties te doen die aansluiten bij jouw API's en codingatterns.

Hier zijn concrete stappen om GitHub Copilot beter te leren van jouw codebase: ## 1. Creëer contextuele codevoorbeelden ```python # Goed voorbeeld - duidelijke patronen def create_user_handler(request_data: dict) -> tuple[dict, int]: """Maakt een nieuwe gebruiker aan met validatie""" try: user = UserService.create_user( username=request_data['username'], email=request_data['email'], password=request_data['password'] ) return {'message': 'Gebruiker aangemaakt', 'user_id': user.id}, 201 except ValueError as e: return {'error': str(e)}, 400 except KeyError: return {'error': 'Ontbrekende vereiste velden'}, 422 ``` ## 2. Gebruik type hints en docstrings ```python from typing import List, Optional from dataclasses import dataclass @dataclass class ApiResponse: success: bool data: Optional[dict] = None message: Optional[str] = None class UserService: @staticmethod def get_user_by_id(user_id: int) -> ApiResponse: """ Haalt gebruiker op op basis van ID Args: user_id: Uniek gebruikers-ID Returns: ApiResponse met gebruikerdata of foutmelding """ # Jouw implementatie hier ``` ## 3. Definieer duidelijke interfacepatronen ```python # services/__init__.py from .user_service import UserService from .auth_service import AuthService from .database_service import DatabaseService __all__ = ['UserService', 'AuthService', 'DatabaseService'] # services/user_service.py class UserService: """Service voor gebruikersgerelateerde operaties""" @classmethod def create_user(cls, username: str, email: str, password: str) -> dict: # Jouw implementatie pass @classmethod def validate_user(cls, user_data: dict) -> bool: # Jouw validatielogica pass ``` ## 4. Maak gebruik van configuratiebestanden ```python # config/copilot_context.py """ Copilot context bestand - Bevat voorkeurspatronen en standaarden """ # Voorkeurs import volgorde IMPORT_PATTERNS = [ 'standard_library', 'third_party', 'local_modules' ] # API response format API_RESPONSE_TEMPLATE = { 'success': bool, 'data': dict, 'message': str, 'status_code': int } ``` ## 5. Feedback mechanisme implementeren ```python # utils/copilot_feedback.py import json from pathlib import Path class CopilotFeedback: """Class voor het geven van feedback aan Copilot""" def __init__(self): self.feedback_file = Path('.copilot/feedback.json') self.feedback_file.parent.mkdir(exist_ok=True) def log_irrelevant_suggestion(self, context: str, suggestion: str): """Logt irrelevante suggesties voor verbetering""" feedback = { 'type': 'irrelevant_suggestion', 'context': context, 'suggestion': suggestion, 'timestamp': datetime.now().isoformat() } with open(self.feedback_file, 'a') as f: f.write(json.dumps(feedback) + '\n') ``` ## 6. Creëer template bestanden ```python # templates/api_handler.py.template """ API Handler Template - Volg dit patroon voor nieuwe API endpoints """ from typing import Dict, Any from dataclasses import dataclass from http import HTTPStatus @dataclass class ApiResponse: success: bool data: Dict[str, Any] = None message: str = '' status_code: int = HTTPStatus.OK def handle_request(request_data: Dict[str, Any]) -> ApiResponse: """ Behandelt API requests volgens standaard patroon Args: request_data: Request data dictionary Returns: Gestandaardiseerde API response """ try: # Implementatie logica hier return ApiResponse( success=True, data={}, message='Operatie succesvol' ) except Exception as e: return ApiResponse( success=False, message=f'Fout: {str(e)}', status_code=HTTPStatus.BAD_REQUEST ) ``` ## 7. Gebruik consistente error handling ```python # errors/custom_errors.py class ApplicationError(Exception): """Basis application error class""" def __init__(self, message: str, status_code: int = 400): self.message = message self.status_code = status_code super().__init__(message) class ValidationError(ApplicationError): """Validation related errors""" pass class DatabaseError(ApplicationError): """Database operation errors""" pass # utils/error_handler.py def handle_api_error(func): """Decorator voor consistente error handling""" def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except ApplicationError as e: return {'error': e.message}, e.status_code except Exception as e: return {'error': 'Interne serverfout'}, 500 return wrapper ``` ## Praktische tips: 1. **Houd bestanden klein en gefocust** (max 200-300 regels) 2. **Gebruik duidelijke, beschrijvende namen** 3. **Schrijf uitgebreide docstrings** 4. **Beperk imports tot wat nodig is per bestand** 5. **Gebruik type hints consistent** 6. **Creëer een `.copilot` directory voor feedback** Door deze patronen consistent toe te passen, zal Copilot beter leren van jouw codebase en meer relevante suggesties genereren.