{
  "title": "Ein Jahr mit Cursor: Wie sich mein Workflow vom Agenten zum Architekten entwickelt hat",
  "excerpt": "Meine Reise mit Cursor spiegelt die Reifung des Tools selbst wider: von einem einfachen Agenten zu einem anspruchsvollen architektonischen Partner. Dieser Beitrag beschreibt, wie sich mein Workflow durch @-Erwähnungen, MCP, Plan Mode und benutzerdefinierte Befehle weiterentwickelt hat.",
  "content_html": "<p>Es ist jetzt über ein Jahr her, dass ich Cursor zu meiner primären IDE gemacht habe, und es ist schwer, die Auswirkungen auf meine Arbeit zu überschätzen. Als Machine-Learning-Ingenieur, der bei Dylog konversationelle KI-Plattformen entwickelt und in meinen persönlichen Projekten mit agentic infrastructure experimentiert, habe ich die Evolution der KI-nativen Entwicklung hautnah miterlebt. Meine Reise mit Cursor spiegelt die Reifung des Tools selbst wider: von einem einfachen Agenten zu einem anspruchsvollen architektonischen Partner.</p>\n<p>Dieser Beitrag ist eine Reflexion über diese Reise. Er beschreibt, wie sich mein Workflow weiterentwickelt hat und wie ich zu einer leistungsstarken Kombination aus Plan Mode, benutzerdefinierten Befehlen und Context Engineering gegriffen habe, um schneller, intelligenter und klarer zu entwickeln.</p>\n<h2>Phase 1: Der Agent übernimmt das Steuer</h2>\n<p>Als ich anfing, war meine Nutzung simpel. Ich habe Cursor wie eine Hochleistungs-Autovervollständigung behandelt. Ich schrieb einen Kommentar, drückte <code>Cmd+K</code> und ließ den Agenten den Code generieren. Es war magisch, aber auch eine Blackbox. Ich war der Passagier, und der Agent fuhr.</p>\n<p>Dann kamen die <strong>@-Erwähnungen</strong>. Das war mein erster Schritt, dem Agenten echten Kontext zu geben. Anstatt zu hoffen, dass er meine Codebasis verstand, konnte ich ihm explizit sagen, worauf er achten sollte:</p>\n<ul>\n<li><code>@file</code>, um eine bestimmte Datei zu referenzieren</li>\n<li><code>@folder</code>, um ein ganzes Verzeichnis einzubeziehen</li>\n<li><code>@codebase</code>, um die Suche über das gesamte Projekt zu ermöglichen</li>\n<li><code>@web</code>, um externe Dokumentation einzubinden</li>\n<li><code>@docs</code>, um offizielle Dokumentationen für Bibliotheken zu referenzieren</li>\n</ul>\n<p>Das war ein gewaltiger Sprung. Plötzlich rät der Agent nicht mehr; er arbeitet mit demselben Kontext wie ich. Ich konnte sagen: „Refaktoriere diese Funktion, damit sie dem Muster in <code>@file:utils/helpers.ts</code> entspricht“, und er verstand es tatsächlich.</p>\n<img src=\"/assets/images/cursor-at-mentions.webp\" alt=\"Cursor @ mention context\" class=\"post-img\" width=\"1639\" height=\"935\">\n<span class=\"post-img-caption\">Das @-Erwähnungs-Dropdown in Cursor, das Kontextoptionen wie @file, @folder, @codebase, @web und @docs zeigt, die eine explizite Kontextsteuerung ermöglichen</span>\n<p>Aber selbst mit besserem Kontext fand ich mich oft in einer Schleife aus Generieren, Debuggen und Neugenerieren wieder. Dem Agenten fehlte die architektonische Vision für größere Aufgaben.</p>\n<h2>Phase 2: MCP verändert alles</h2>\n<p>Mit der Einführung des <strong>Model Context Protocol (MCP)</strong> wurde es ernst. MCP ermöglichte es mir, Cursor mit externen Tools und Datenquellen zu verbinden und verwandelte den Agenten von einem Code-Generator in einen echten Assistenten mit Zugriff auf meinen gesamten Workflow.</p>\n<p>Ich begann, MCPs zu integrieren für:</p>\n<ul>\n<li><strong>GitHub</strong>, um Issues und PRs direkt in den Kontext zu ziehen</li>\n<li><strong>Linear</strong>, für die Integration des Task-Managements</li>\n<li><strong>Slack</strong>, für Kontext aus der Team-Kommunikation</li>\n<li><strong>Custom MCPs</strong>, für interne APIs und Datenbanken</li>\n</ul>\n<p>Mit MCP konnte ich sagen: „Implementiere das Feature, das in Linear Issue #234 beschrieben ist“, und der Agent würde das Issue abrufen, die Anforderungen verstehen und mit der Entwicklung beginnen. Es ging nicht mehr nur um Code; es ging darum, die Punkte in meinem gesamten Entwicklungs-Ökosystem zu verbinden.</p>\n<img src=\"/assets/images/cursor-mcp-integrations.webp\" alt=\"MCP integrations in Cursor\" class=\"post-img\" width=\"1639\" height=\"935\">\n<span class=\"post-img-caption\">MCP-Konfigurationspanel, das verbundene Integrationen wie GitHub, Linear, Slack und benutzerdefinierte Server zeigt, die Cursors Fähigkeiten über das gesamte Entwicklungs-Ökosystem erweitern</span>\n<h2>Phase 3: Der Aufstieg des Planers</h2>\n<p>Die Einführung des <strong>Plan Mode</strong> war der nächste Game-Changer. Es war das erste Mal, dass ich das Gefühl hatte, mit der KI zu kollaborieren, anstatt ihr nur Aufgaben zu delegieren. Inspiriert von Workflows von Entwicklern wie Ray Fernando, begann ich, einen zweistufigen Prozess zu nutzen:</p>\n<ol>\n<li><strong>Planen mit Opus:</strong> Ich nutzte ein leistungsstarkes Modell wie Claude Opus, um einen detaillierten, Schritt-für-Schritt-Implementierungsplan zu erstellen. Ich gab ihm das übergeordnete Ziel vor, und es zerlegte dieses in eine Reihe konkreter Aufgaben, komplett mit Dateinamen, Funktionssignaturen und Logik.</li>\n<li><strong>Ausführen mit Sonnet/GPT:</strong> Anschließend übergab ich diesen Plan an ein schnelleres, günstigeres Modell wie Sonnet oder GPT-5.2, um jeden Schritt auszuführen. Das günstigere Modell musste kein brillanter Architekt sein; es musste nur ein gewissenhafter Bauarbeiter sein.</li>\n</ol>\n<p>Dieser Workflow war eine massive Verbesserung. Er trennte das „Was“ vom „Wie“ und gab mir ein überprüfbares Artefakt – den Plan –, das ich bearbeiten und genehmigen konnte, bevor auch nur eine Zeile Code geschrieben wurde. Außerdem sparte er eine Menge Geld für Tokens.</p>\n<img src=\"/assets/images/cursor-plan-mode.webp\" alt=\"Cursor Plan Mode workflow\" class=\"post-img\" width=\"1639\" height=\"935\">\n<span class=\"post-img-caption\">Eine geteilte Ansicht, die links einen detaillierten Implementierungsplan in einer <code>.cursor/plans/</code>-Datei und rechts den entsprechenden generierten Code zeigt, was die Trennung von Architektur und Ausführung demonstriert</span>\n<h2>Phase 4: Der Architekt tritt hervor (Befehle + Planung)</h2>\n<p>Hier befinde ich mich heute. Während Plan Mode weiterhin zentraler Bestandteil meines Workflows ist, habe ich eine Reihe von <strong>benutzerdefinierten Befehlen</strong> und <strong>Regeln</strong> hinzugefügt, um den Prozess zu verfeinern und meine architektonischen Prinzipien direkt in die IDE zu integrieren.</p>\n<h3>Mein aktuelles Setup</h3>\n<p><strong>Rules (<code>.cursorrules</code>):</strong> Ich habe eine Reihe von Regeln, die meine Coding-Standards, bevorzugte Patterns und architektonische Einschränkungen definieren. Der Agent liest diese vor jeder Aufgabe, um Konsistenz über die gesamte Codebasis hinweg sicherzustellen.</p>\n<p><strong>Benutzerdefinierte Befehle:</strong> Ich habe Befehle erstellt, die meine häufigsten Workflows kapseln:</p>\n<ul>\n<li><code>/plan</code> – Erstellt einen detaillierten Implementierungsplan mit Opus</li>\n<li><code>/refactor</code> – Nimmt eine Datei und refaktoriert sie basierend auf Anweisungen</li>\n<li><code>/test</code> – Generiert eine Test-Suite für eine gegebene Funktion</li>\n<li><code>/review</code> – Überprüft Code anhand meiner Regeln und schlägt Verbesserungen vor</li>\n</ul>\n<p><strong>Queued Messages:</strong> Ich nutze <code>Ctrl+Enter</code>, um Folgeanweisungen in die Warteschlange zu stellen, während der Agent arbeitet. Das erlaubt es mir, vorauszudenken und den Schwung aufrechtzuerhalten, ohne die aktuelle Aufgabe zu unterbrechen.</p>\n<img src=\"/assets/images/cursor-custom-commands.webp\" alt=\"Cursor custom commands and rules\" class=\"post-img\" width=\"1639\" height=\"935\">\n<span class=\"post-img-caption\">Die Cursor-Befehlspalette, die benutzerdefinierte Befehle wie /plan, /refactor, /test und /review zeigt, neben einer <code>.cursorrules</code>-Datei, die Coding-Standards und architektonische Einschränkungen definiert</span>\n<h2>Die Evolution auf einen Blick</h2>\n<table>\n<thead>\n<tr>\n<th>Phase</th>\n<th>Wichtigstes Feature</th>\n<th>Was sich verändert hat</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Agent Mode + @ Mentions</td>\n<td>Kontext wurde explizit, nicht erraten</td>\n</tr>\n<tr>\n<td>2</td>\n<td>MCP Integration</td>\n<td>Externe Tools und Daten wurden zugänglich</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Plan Mode</td>\n<td>Architektur wurde von der Ausführung getrennt</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Commands + Rules</td>\n<td>Workflows wurden wiederholbar und personalisiert</td>\n</tr>\n</tbody>\n</table>\n<h2>Warum das wichtig ist</h2>\n<p>Diese Entwicklung vom Agenten zum Architekten ist mehr als nur ein persönlicher Produktivitäts-Hack. Sie ist ein Einblick in die Zukunft der Softwareentwicklung. Wir bewegen uns von einer Welt, in der wir Code schreiben, zu einer Welt, in der wir <strong>Systeme beschreiben</strong>. Unsere Aufgabe ist es, der Architekt zu sein, den Bauplan zu definieren und die Agenten das Bauen zu lassen.</p>\n<p>Cursor versteht diese Verschiebung mehr als jedes andere Tool, das ich je genutzt habe. Es geht nicht nur darum, Code zu generieren; es geht darum, Komplexität zu managen, Kontext zu bewahren und Entwicklern die Hebelwirkung zu geben, um in einem Ausmaß zu bauen, das zuvor unvorstellbar war.</p>\n<p>Wenn du KI noch immer als einfachen Code-Generator nutzt, ermutige ich dich, @-Erwähnungen, MCP, Plan Mode und benutzerdefinierte Befehle zu erkunden. Es ist eine Reise, die dich von einem Entwickler, der KI nutzt, zu einem Architekten verwandeln wird, der sie dirigiert.</p>",
  "source_hash": "sha256:414a9187cf9ba648188a0c14e26a1e88844cad86a23d18e16d6b9df6b5c9add2",
  "model": "moonshotai/kimi-k2.6",
  "generated_at": "2026-08-07T07:15:14.120505+00:00"
}