Creëer een op maat gemaakte Cursor-assistent voor persoonlijke code-analyse en optimalisatie
description
Met deze prompt kun je een op maat gemaakte Cursor-assistent creëren die jouw codebase continu monitort en analyseert, waardoor je sneller inzicht krijgt in verbeterpunten zoals efficiëntie, stijl en security. Dit gaat verder dan standaard Cursor-functies door een gepersonaliseerde, proactieve ondersteuning te bieden die is afgestemd op jouw project en programmeertaal.
prompt
try_prompt
Help me een persoonlijke Cursor-assistent te ontwikkelen die mijn codebase continu analyseert op efficiëntie, stijlconsistentie en potentiële verbeterpunten. Mijn programmeertaal: <voer je programmeertaal in>. Beschrijf mijn codebase of project: <beschri ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een stapsgewijze aanpak om een persoonlijke Cursor-assistent te ontwikkelen die je Python-codebase voor je webapplicatie voor data-analyse continu analyseert op efficiëntie, stijlconsistentie, prestaties en beveiliging:
Stap 1: Voorbereiding en Vereisten vaststellen
- Zorg dat je een werkende Python-omgeving hebt.
- Installeer Cursor en gerelateerde tools:
```bash
pip install cursor
```
- Zorg dat je toegang hebt tot je codebase, bijvoorbeeld via een Git-repository.
Stap 2: Cursor Configuratie en Integratie
- Maak een Cursor-project aan:
```bash
cursor init
```
- Voeg je project toe:
```bash
cursor add /pad/naar/je/codebase
```
- Configureer Cursor via `.cursor/config.yaml` om specifieke analysethema's te richten:
```yaml
themes:
- style
- performance
- security
```
Stap 3: Analysethema's specificeren
Voor elk thema kun je specifieke checks en regels instellen:
a) **Stijl en Efficiëntie**
- Gebruik de ingebouwde PEP8- en Pylint-controles.
- Voeg custom regels toe voor coding style, bijvoorbeeld:
```yaml
style:
include:
- pep8
- pylint
```
b) **Prestaties**
- Installeer en configureer tools zoals line_profiler of cProfile om codeprestaties te monitoren.
- Voeg aangepaste scripts toe die je code kunnen analyseren op veelgebruikte bottlenecks.
c) **Beveiliging**
- Voeg scripts toe die bijvoorbeeld controleren op:
- Hardcoded wachtwoorden
- Onveilige imports of gebruik van onveilige functies
- Open poorten of debug-modi in productie
- Gebruik statische analysetools zoals Bandit:
```bash
pip install bandit
```
- Integreer Bandit in Cursor via aangepaste checks.
Stap 4: Automatiseren en Continu Integreren
- Configureer een CI/CD pipeline die:
- Bij elke commit of pull request automatisch Cursor analyses uitvoert.
- Rapporten genereert met verbeterpunten.
- Gebruik bijvoorbeeld GitHub Actions of GitLab CI.
Stap 5: Rapportage en Feedback
- Bekijk de rapporten in Cursor dashboards.
- Stel alerts in voor kritieke beveiligingsissues of prestatieproblemen.
- Implementeer automatische feedback of suggesties op basis van de analyses.
Stap 6: Optimalisatie en Onderhoud
- Pas de configuratie aan op basis van de resultaten.
- Voeg nieuwe checks toe naarmate je project evolueert.
- Houd Cursor en dependencies up-to-date.
Door deze stappen te volgen, ontwikkel je een krachtige, continue analyse-assistent die je codebase optimaliseert op stijl, prestaties en beveiliging met behulp van Cursor.
provider: deepseek
model: deepseek-chat
Hier is een stapsgewijze aanpak om je persoonlijke Cursor-assistent te ontwikkelen voor je Python webapplicatie:
## Stap 1: Cursor Installatie en Basisconfiguratie
```bash
# Installeer Cursor via de officiële website
# Maak een .cursorrules bestand in je projectroot
```
## Stap 2: Configureer Analyse Regels
Maak een `.cursorrules` bestand met:
```python
# CURSOR CONFIGURATIE - DATA-ANALYSE WEBAPPLICATIE
TAAL: Python
FOCUS: Prestaties & Beveiliging
# PRESTATIE ANALYSE REGELS
- Identificeer trage database queries (N+1 problemen)
- Analyseer algoritmische complexiteit (Big-O)
- Controleer caching strategieën
- Optimaliseer geheugengebruik bij data-verwerking
- Scan voor overbodige database calls
- Controleer response times van API endpoints
# BEVEILIGING ANALYSE REGELS
- Detecteer SQL injection kwetsbaarheden
- Valideer input sanitization
- Controleer authentication/authorization flows
- Scan voor hardcoded credentials
- Analyseer session management
- Check CSRF bescherming
- Review dependency vulnerabilities
```
## Stap 3: Project-specifieke Context
Voeg projectcontext toe aan je regels:
```python
# PROJECT CONTEXT
PROJECT_TYPE: Data-analyse webapplicatie
TECH_STACK: Python, mogelijk Flask/Django, database, data-processing libraries
DATA_SCALE: Medium tot grote datasets
BEVEILIGINGSNIVEAU: Hoog (data-sensitive applicatie)
# SPECIFIEKE CONTROLEPUNTEN
- Data processing efficiency bij grote datasets
- API endpoint security voor data-access
- Query optimalisatie voor analytische queries
- Rate limiting implementatie
- Data encryption in transit en at rest
```
## Stap 4: Implementatie Workflow
1. **Eerste Codebase Scan**
```bash
# Gebruik Cursor's AI om complete codebase te analyseren
# Vraag: "Analyseer mijn complete codebase voor prestatie-issues"
```
2. **Prestatie-specifieke Commando's**
```
/analyse prestaties: database queries
/analyse prestaties: algoritmische complexiteit
/analyse prestaties: caching optimalisatie
```
3. **Beveiligings-specifieke Commando's**
```
/scan beveiliging: input validatie
/scan beveiliging: authentication
/scan beveiliging: data protection
```
## Stap 5: Continue Optimalisatie
### Automatische Checks
```python
# Voeg deze regels toe voor automatische detectie
AUTOMATISCHE_DETECTIE:
- Trage queries in data-processing functies
- Onveilige string concatenatie in SQL
- Missing input validation
- Inefficiënte loops bij data-verwerking
- Overhead in API response generatie
```
### Prestatie Metrics Tracking
```python
# Focus op deze prestatie-indicatoren
PRESTATIE_METRICS:
- Query execution time > 100ms
- Memory usage spikes
- Response time > 500ms
- Concurrent user handling
- Data processing throughput
```
## Stap 6: Beveiligings Audit Regels
```python
BEVEILIGING_AUDIT:
CRITICAL:
- SQL injection mogelijkheden
- Authentication bypass
- Sensitive data exposure
HIGH:
- CSRF vulnerabilities
- Session fixation
- Insecure direct object references
MEDIUM:
- Missing security headers
- Information disclosure in errors
```
## Stap 7: Gebruikspatronen voor Dagelijks Gebruik
1. **Voor Nieuwe Features**
```
"Review deze nieuwe feature code voor prestatie-impact en beveiligingsrisico's"
```
2. **Voor Code Reviews**
```
"Analyseer deze pull request op: prestatie-regressie, beveiligingsissues"
```
3. **Periodieke Health Checks**
```
"Voer complete security audit uit op de codebase"
"Identificeer prestatie bottlenecks in de data-verwerkingslaag"
```
## Stap 8: Optimalisatie en Fine-tuning
### Feedback Loop
```python
# Leer van eerdere analyses
LEER_PATRONEN:
- Herhaalde prestatie issues
- Veelvoorkomende beveiligingsantipatterns
- Project-specifieke optimalisatie kansen
```
### Contextuele Verbeteringen
- Pas regels aan op basis van je specifieke frameworks
- Voeg domein-specifieke beveiligingsregels toe
- Optimaliseer voor je data-analyse use cases
## Start Commando's om Mee te Beginnen:
1. `"Scan mijn complete codebase voor kritieke beveiligingsissues"`
2. `"Identificeer de top 5 prestatie bottlenecks in mijn applicatie"`
3. `"Analyseer mijn database access layer voor optimalisatie kansen"`
Deze setup zorgt voor een proactieve assistent die continu je codebase monitort en specifiek focust op de prestatie en beveiligingsaspecten van je data-analyse webapplicatie.

