Ja. **Und genau dafür ist IntelliJ inzwischen viel interessanter als früher.** Dein gewünschter Workflow ist 2026 erstaunlich nah an „nativ vorhanden“. Der entscheidende Punkt: Ich würde den Agenten **nicht nur per Computer Vision auf deinen Bildschirm schauen lassen**. Das wäre eigentlich die primitive Variante. IntelliJ kann dem Agenten inzwischen seinen **semantischen IDE-Zustand direkt zugänglich machen**. IntelliJ IDEA 2026.2 hat einen integrierten **MCP-Server**. Externe Agents können darüber unter anderem offene Dateien, IDE-Inspections, Projektstruktur und weitere IDE-Funktionen abfragen. Seit 2026.1/2026.2 sind außerdem **Codex, Claude Agent, Junie und andere ACP-kompatible Agents direkt in der IDE integrierbar**. ([JetBrains][1]) Das heißt, ich würde dein System so denken: ```text DU │ ┌────────┴────────┐ │ │ Tastatur Stimme │ │ ▼ ▼ ┌──────────────────────────────┐ │ INTELLIJ IDEA │ │ │ │ Project Tree Editor │ │ Debugger Terminal │ │ Git Inspections │ │ Run Configs Database │ └──────────────┬───────────────┘ │ IDE MCP Server │ ┌──────────┴──────────┐ ▼ ▼ Claude/Codex/Junie Visual Agent semantic context Screenshot/Computer Use │ │ └──────────┬──────────┘ ▼ dein Co-Pilot ``` Und **das ist meiner Meinung nach ziemlich genau das Lerninterface, das dir bisher gefehlt hat.** ### Der Agent sollte nicht für dich coden Das ist der wichtige Unterschied zu deinem normalen agentischen Arbeiten. Du setzt ihn zunächst auf **Read-only / Plan / Guide**. Du schreibst selbst und sagst währenddessen einfach: > „Was ist dieses Symbol links neben der Klasse?“ > „Warum zeigt IntelliJ mir hier drei Module?“ > „Was ist eigentlich eine Run Configuration?“ > „Ich habe gerade Cmd-B gedrückt. Was hat die IDE jetzt semantisch gemacht?“ > „Warum ist diese Variable grau?“ > „Was bedeutet dieser gelbe Balken rechts?“ > „Woher weiß IntelliJ, dass diese Methode hier aufgerufen wird?“ > „Was ist der Unterschied zwischen Project, Packages und Project Files?“ Und der Agent muss nicht raten. Er kann beispielsweise die offenen Dateien und IntelliJ-Inspections tatsächlich abfragen. JetBrains exponiert dafür MCP-Tools wie `get_all_open_file_paths` und `get_file_problems`. ([YouTrack][2]) Das ist **wesentlich besser als ein Tutor, dem du ständig Screenshots schicken musst.** ### Computer Use würde ich trotzdem hinzufügen Aber als **zweiten Wahrnehmungskanal**. MCP beantwortet: > „Was ist der Zustand der IDE?“ Vision beantwortet: > „Was sieht Samuel gerade?“ Das sind unterschiedliche Informationen. Wenn du beispielsweise sagst: > „Was ist dieses Ding rechts oben?“ braucht ein rein semantischer Agent womöglich Referenzinformation. Ein multimodaler Agent sieht dagegen: **Ah — Samuel meint das Inspection Widget.** Dann könnte er über MCP zusätzlich feststellen: **Es gibt gerade zwei Warnings und einen Error in dieser Datei.** Genau die Kombination ist stark: **Pixels + IDE semantics + repository + terminal + debugger.** Und gerade der Debugger wird spannend. Junie kann inzwischen über JetBrains' Debugger-MCP beispielsweise Call Stacks untersuchen, Variablen im aktuellen Frame ansehen, Expressions evaluieren und Breakpoints setzen. ([JetBrains][3]) Damit kannst du irgendwann sagen: > „Stopp. Ich verstehe gerade nicht, warum das Programm hier landet.“ Und der Tutor kann antworten: > „Du bist gerade in `foo()`. Der Aufruf kam über `bar() → baz() → foo()`. Schau links unten in den Call Stack. Klick mal nicht. Versuch zuerst selbst zu sagen, warum wir hier gelandet sind.“ **Das wäre richtig gutes agentisches Lernen.** --- ### Ich würde bei dir sogar absichtlich IntelliJ statt Neovim nehmen Nicht dauerhaft. Sondern als **Learning Cockpit**. Neovim/Helix sind hervorragend, wenn du bereits weißt, was du tust. Ihre Stärke ist geringe Interface-Entropie. IntelliJ hingegen externalisiert extrem viel Programmlogik: * Typinformationen * Referenzen * Call Hierarchies * Inheritance * Dependencies * Git State * Test Runner * Debugger * Profiler * Datenbanken * Inspections * Refactorings * Buildsystem Wenn daneben ein Lehrer sitzt, der dir **jede dieser Repräsentationen on demand erklärt**, wird aus dem ganzen IDE-Chrom plötzlich kein Ballast mehr, sondern ein **Visualisierungsinstrument für Software Engineering**. Das passt viel besser zu deinem Ziel, nicht bloß Agenten anzustoßen, sondern wirklich zu verstehen, **was unterhalb des Harness passiert**. ### Konkreter Minimalaufbau Du kannst tatsächlich ziemlich simpel anfangen: 1. **IntelliJ IDEA 2026.2 auf dem M3 Max installieren.** 2. Hochschullizenz aktivieren. Das Student Pack umfasst IntelliJ IDEA Ultimate und die übrigen JetBrains-IDEs. Wichtig: Die kostenlose Education-Lizenz darf nicht für kommerzielle Arbeit verwendet werden. ([JetBrains Sales][4]) 3. **AI Assistant Plugin installieren.** 4. `Settings → Tools → MCP Server → Enable MCP Server`. Der MCP-Server ist seit IntelliJ 2025.2 integriert. ([JetBrains][1]) 5. Im AI Chat **Codex oder Claude Agent** auswählen. IntelliJ unterstützt beide inzwischen direkt; zusätzliche ACP-Agents kannst du ebenfalls anbinden. ([JetBrains][5]) 6. Agent zunächst **Read-only / Plan** laufen lassen. 7. Für Sprache zunächst schlicht **macOS-Diktat → AI Chat** benutzen. Deine Education-Lizenz bekommt auch **JetBrains AI Free**, mit einem kleinen Cloud-Credit-Kontingent; AI Pro/Ultimate sind nicht im Student Pack enthalten. Junie lässt sich damit ebenfalls aktivieren. ([YouTrack][6]) Und **erst danach** würde ich die letzte, für dich eigentlich interessante Schicht bauen: ### `hai-ide-observer` Ein kleiner HAI-Agent, der drei Inputs bekommt: ```text VOICE "What is that blue symbol next to the function?" IDE MCP current_file cursor_position diagnostics symbol_under_cursor project_structure debug_state VISION current IntelliJ screenshot ``` und als Output ausschließlich: ```text EXPLAIN POINT ASK SUGGEST ``` aber standardmäßig **kein `EDIT`**. Dann wäre dein Agent nicht mehr primär ein Coding Agent. Er wäre ein **permanenter Pair-Programming-Lehrer**, der deine Aufmerksamkeit mitverfolgt. Und das halte ich bei dir für wesentlich interessanter als noch ein weiterer „mach Issue #37 autonom fertig“-Agent. Du könntest dann tatsächlich eine Stunde lang selbst Python/Java/Kotlin schreiben und einfach im Raum reden: **„Warum passiert das?“ — „Was bedeutet das?“ — „Wo bin ich gerade?“ — „Zeig mir das Konzept hinter dieser IDE-Funktion.“** Das wäre fast schon die andere Hälfte des HAI: **nicht Human → Agent Delegation, sondern Agent → Human Cognitive Augmentation.** [1]: https://www.jetbrains.com/help/ai-assistant/mcp.html?utm_source=chatgpt.com "Model Context Protocol (MCP) | AI Assistant Documentation" [2]: https://youtrack.jetbrains.com/projects/GTW/articles/SUPPORT-A-2156/MCP-Available-Tools?utm_source=chatgpt.com "MCP Available Tools | Knowledge Base" [3]: https://www.jetbrains.com/help/ai-assistant/junie-agent.html?utm_source=chatgpt.com "Junie by JetBrains | AI Assistant Documentation" [4]: https://sales.jetbrains.com/hc/de/articles/207241195-Bieten-Sie-kostenlose-Bildungslizenzen-f%C3%BCr-Lernende-und-Lehrkr%C3%A4fte-an?utm_source=chatgpt.com "Bieten Sie kostenlose Bildungslizenzen für Lernende und Lehrkräfte an? – Häufig gestellte Fragen zur Lizenzierung und Beschaffung" [5]: https://www.jetbrains.com/help/ai-assistant/agents.html?utm_source=chatgpt.com "Agents | AI Assistant Documentation" [6]: https://youtrack.jetbrains.com/articles/SUPPORT-A-395?utm_source=chatgpt.com "Is AI Assistant included/available in the IDE students/educational pack subscription | Knowledge Base"