Einführung in Cursor und KI-gestützte Softwareentwicklung

• Was ist Cursor? Architektur und Funktionsweise
• Cursor als KI-gestützter Code-Editor und Coding-Agent
• Unterschiede zwischen klassischer IDE und KI-basierter Entwicklungsumgebung
• KI-Modelle in Cursor
  • Modelle von OpenAI, Anthropic, Google und weiteren Anbietern
  • Cursor-eigene Modelle
  • Auswahl geeigneter Modelle für unterschiedliche Entwicklungsaufgaben
  • Kosten, Tokenverbrauch und Kontextfenster
• AI-Assisted Coding, Vibe Coding und Agentic Coding
• Vergleich mit GitHub Copilot, Claude Code und OpenAI Codex
• Möglichkeiten und Grenzen KI-generierten Codes

Cursor installieren, konfigurieren und kennenlernen

• Installation und Einrichtung von Cursor
• Übernahme bestehender Visual-Studio-Code-Einstellungen
• Benutzeroberfläche und Entwicklungsumgebung
• Konfiguration von KI-Modellen
• Datenschutz- und Sicherheitseinstellungen
• Arbeiten mit lokalen Projekten und Git-Repositories
• Integration von Terminal, Git und Debugger
• Tastenkombinationen und effiziente Bedienung
• Cursor in bestehenden Entwicklungsprojekten einsetzen

KI-gestützte Programmierung mit Cursor

• Code Completion und intelligente Codevorschläge
• Mehrzeilige Codevervollständigung mit Cursor Tab
• Inline Edit zur direkten Bearbeitung von Quellcode
• Chat mit der KI über Quellcode und Architektur
• Fragen zu bestehenden Implementierungen stellen
• Code generieren und bestehende Funktionen erweitern
• Code zwischen Programmiersprachen übersetzen
• Kommentare und Dokumentation generieren
• Repository-weite Codeänderungen durchführen
• Änderungen überprüfen und gezielt übernehmen

Kontextverwaltung und Prompt Engineering in Cursor

• Effektives Prompt Engineering für Softwareentwickler
• Kontextinformationen gezielt bereitstellen
• Codebase Indexing und semantische Codesuche
• Dateien, Ordner und Quellcode referenzieren
• Architekturvorgaben und Entwicklungsrichtlinien berücksichtigen
• Große Codebasen analysieren
• Kontextfenster und Tokenverbrauch optimieren
• Wiederverwendbare Prompts und Anweisungen
• Plan Mode zur strukturierten Vorbereitung komplexer Aufgaben
• Spec-Driven Development mit Cursor

Agentische Softwareentwicklung mit Cursor Agent

• Funktionsweise des Cursor Agents
• Unterschiede zwischen Chat, Inline Edit und Agent
• Die Agentic Loop
  • Anforderungen analysieren
  • Implementierung planen
  • Quellcode verändern
  • Werkzeuge und Terminalbefehle ausführen
  • Ergebnisse durch Tests überprüfen
• Komplexe Features autonom implementieren
• Änderungen über mehrere Dateien und Projekte hinweg durchführen
• Terminalbefehle und Buildprozesse ausführen lassen
• Automatisierte Fehleranalyse und Fehlerbehebung
• Agenten bei der Arbeit überwachen und steuern
• Parallele Agenten und Aufgabenverteilung
• Git Worktrees für isolierte Entwicklungsaufgaben
• Grenzen und Risiken autonomer Codeänderungen

Refactoring, Debugging und Testing mit Cursor

• Bestehende Anwendungen analysieren und verstehen
• Code Smells und technische Schulden erkennen
• Refactoring einzelner Funktionen und ganzer Module
• Modernisierung bestehender Anwendungen
• Fehler anhand von Logs und Stack Traces analysieren
• Fehlerursachen systematisch ermitteln
• Fehlerkorrekturen mit Cursor Agent implementieren
• Unit Tests und Integrationstests generieren
• Testgetriebene Entwicklung (TDD) mit KI-Unterstützung
• Fehlgeschlagene Tests automatisiert analysieren
• Code Reviews durchführen
• Performanceprobleme und Sicherheitslücken identifizieren

Cursor erweitern: Rules, Skills, Commands, Hooks und Plugins

• Anpassungsmöglichkeiten von Cursor
• Cursor Rules
  • Projektweite und globale Regeln
  • Konfiguration über .cursor/rules
  • Coding Guidelines und Architekturvorgaben
  • Wiederverwendbare Entwicklungsrichtlinien
• Agent Skills
  • Aufbau und Funktionsweise von Skills
  • Eigene Skills erstellen
  • Wiederkehrende Entwicklungsaufgaben standardisieren
• Wiederverwendbare Agent-Anweisungen und Commands
• Hooks zur Automatisierung von Entwicklungsabläufen
• Plugins und Erweiterungen
• Gemeinsame Konfigurationen für Entwicklungsteams

Model Context Protocol (MCP) mit Cursor

• Einführung in das Model Context Protocol
• MCP-Architektur
  • MCP Hosts
  • MCP Clients
  • MCP Server
• Cursor als MCP-Host einsetzen
• MCP-Server konfigurieren und anbinden
• MCP Tools, Resources und Prompts
• Externe Datenquellen und Werkzeuge integrieren
  • GitHub und GitLab
  • Relationale Datenbanken
  • REST-APIs
  • Jira und andere Issue-Tracking-Systeme
  • Browserautomatisierung
• Eigene MCP-Server entwickeln
• Authentifizierung und Autorisierung
• Sicherheitsaspekte bei MCP-Integrationen

Cursor CLI – KI-Agenten über die Kommandozeile verwenden

• Einführung in die Cursor CLI
• Installation und Konfiguration
• Authentifizierung und Modellauswahl
• Interaktive und nicht interaktive Nutzung
• Entwicklungsaufgaben über die Kommandozeile ausführen
• Automatisierte Codeanalyse und Codegenerierung
• Cursor CLI in Shell-Skripte integrieren
• Automatisierte Tests und Code Reviews
• Cursor CLI in Build- und CI/CD-Prozessen verwenden
• Unterschiede zwischen Cursor CLI und Cursor Cloud Agents

Cursor Cloud Agents – Softwareentwicklung in der Cloud

• Architektur und Funktionsweise der Cursor Cloud Agents
• Unterschiede zwischen lokalen und cloudbasierten Coding-Agenten
• Cloud Agents erstellen und konfigurieren
• Verbindung zu Git-Repositories
• Entwicklungsumgebungen für Cloud Agents einrichten
• Isolierte Entwicklungsumgebungen und virtuelle Maschinen
• Komplexe Entwicklungsaufgaben delegieren
• Mehrere Agenten parallel ausführen
• Aufgaben über mehrere Repositories hinweg bearbeiten
• Pull Requests automatisch erstellen
• Ergebnisse überprüfen und Änderungen übernehmen
• Cloud Agents mit MCP und externen Diensten erweitern

Cursor APIs – Coding-Agenten programmatisch steuern

• Überblick über die Cursor APIs
• Unterschiede zwischen Editor, CLI und Cloud Agents API
• Authentifizierung mit API-Schlüsseln
• REST-API mit HTTP und JSON verwenden
• API-Versionierung und Fehlerbehandlung
• Cursor Cloud Agents API
  • Agenten über POST /v1/agents erstellen
  • Agenten über GET /v1/agents auflisten
  • Agenteninformationen abrufen
  • Weitere Aufgaben über Agent Runs starten
  • Status und Ergebnisse von Agent Runs abfragen
  • Agenten abbrechen, archivieren und verwalten
• KI-Modelle und Modellparameter über die API auswählen
• Git-Repositories als Arbeitsgrundlage definieren
• MCP-Server über die API konfigurieren
• Automatische Pull-Request-Erstellung
• Artefakte und Arbeitsergebnisse abrufen
• Rate Limits und Fehlerbehandlung
• API-Aufrufe mit C#, TypeScript oder Python implementieren

Cursor SDKs – Eigene Anwendungen mit Coding-Agenten entwickeln

• Überblick über die Cursor SDKs
• Unterschiede zwischen REST-API und SDK
• SDK installieren und konfigurieren
• Authentifizierung und API-Zugriff
• Cloud Agents programmatisch starten
• Agenten mit natürlichsprachlichen Aufgaben versorgen
• Agent Runs und Ausführungsstatus verwalten
• Arbeitsergebnisse und Artefakte verarbeiten
• Agenten in eigene Anwendungen integrieren
• Eigene Entwicklerwerkzeuge mit Cursor Agents erstellen
• Automatisierte Entwicklungsprozesse implementieren
• Fehlerbehandlung, Logging und Monitoring

DevOps mit Cursor: Git, GitHub und CI/CD mit Cursor automatisieren

• Git-Repositories mit Cursor analysieren
• Commits und Commit-Nachrichten generieren
• Branches und Pull Requests verwalten
• KI-gestützte Code Reviews
• Cursor CLI in GitHub Actions einsetzen
• Cloud Agents aus CI/CD-Prozessen starten
• Automatisierte Fehlerbehebung bei fehlgeschlagenen Builds
• Issue-basierte Softwareentwicklung
• Agenten mit externen Ticketsystemen verbinden
• Automatisierte Dokumentation und Qualitätssicherung
• Human-in-the-Loop und Freigabeprozesse

Sicherheit, Datenschutz und Kostenkontrolle

• Datenschutz und Privacy Mode in Cursor
• Verarbeitung von Quellcode durch externe KI-Modelle
• Schutz vertraulicher Quelltexte und Zugangsdaten
• Absicherung von API-Schlüsseln
• Berechtigungen für lokale und cloudbasierte Agenten
• Sicherheitsrisiken durch Prompt Injection
• Risiken automatisierter Terminalbefehle
• Schutz vor unbeabsichtigten Repository-Änderungen
• Sicherheitskonzepte für MCP-Server
• Tokenverbrauch und Modellkosten optimieren
• Verbrauch und Kosten der Cloud Agents API überwachen
• Qualitätssicherung bei KI-generiertem Code
• Richtlinien für den unternehmensweiten Einsatz

Praxisszenarien

• Ein bestehendes Softwareprojekt mit Cursor analysieren
• Eine neue Funktion mit Cursor Agent implementieren
• Bestehenden Code automatisiert refaktorieren
• Fehler analysieren und durch generierte Tests absichern
• Eigene Cursor Rules und Skills erstellen
• Einen MCP-Server anbinden
• Einen Entwicklungsprozess mit Cursor CLI automatisieren
• Einen Cloud Agent über die REST-API starten
• Agent Runs programmatisch überwachen und steuern
• Einen Pull Request durch einen Cloud Agent erstellen lassen
• Die Cursor API in eine eigene Anwendung integrieren
• Einen automatisierten Entwicklungsworkflow über ein SDK implementieren

Vergleich und Ausblick

• Cursor im Vergleich mit GitHub Copilot, Claude Code und OpenAI Codex
• Cursor APIs im Vergleich mit anderen Coding-Agent-APIs
• Unterschiede zwischen Cursor Agents und allgemeinen KI-Agenten
• Kombination von Cursor mit OpenAI API und Anthropic API
• Möglichkeiten und Grenzen autonomer Softwareentwicklung
• Aktuelle Entwicklungen bei Agentic Coding und Multi-Agent-Systemen