Plan

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"