[FEATURE] IntelliJ IDEA plugin for Claude Code (like VS Code extension)

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Claude Code currently offers a GUI experience through the VS Code extension (Beta), but users of other IDEs like IntelliJ IDEA, WebStorm, PyCharm, and other JetBrains products are limited to the CLI interface
only.

As an IntelliJ IDEA user, I need to:

• Switch between my IDE and terminal constantly
• Manage conversations through text-based CLI (claude -r) which lacks visual organization
• Review code changes in the terminal instead of seeing inline diffs in my editor
• Manually navigate to files that Claude modifies rather than seeing them highlighted in my IDE

The current workflow requires me to context-switch between IntelliJ and terminal, which disrupts my development flow. While the CLI is powerful, it lacks the integrated, visual experience that VS Code users enjoy
with the extension.

JetBrains IDEs have a massive user base in the enterprise and professional development world, especially for Java, Kotlin, Python, JavaScript, and Go development. Without IDE integration, these users are getting
a second-class experience compared to VS Code users.

Proposed Solution

Create an IntelliJ IDEA plugin (and potentially other JetBrains IDE plugins) that provides the same GUI experience as the VS Code extension.

Core features (matching VS Code extension):

1. Sidebar Panel:

• Claude Code chat interface embedded in the IDE sidebar
• Similar to the "Spark icon" panel in VS Code

1. Visual Code Review:

• Inline diff view for Claude's proposed changes
• Side-by-side comparison before accepting changes
• Ability to accept/reject individual changes

1. Real-time File Highlighting:

• Automatically open and highlight files that Claude modifies
• Show changed lines in the editor with diff markers

1. Conversation Management:

• Visual list of conversation history
• Search and filter conversations
• Clear visual indication of active conversation

1. Configuration Integration:

• Read from the same ~/.claude/settings.json configuration
• Support for third-party providers (Amazon Bedrock, Google Vertex AI)
• MCP server configuration

1. Plan Review Mode:

• Review Claude's implementation plans before execution
• Optional auto-accept mode for trusted operations

The interface should:

• Feel native to IntelliJ (follow JetBrains UI/UX guidelines)
• Support all JetBrains IDEs (IDEA, WebStorm, PyCharm, GoLand, etc.) through a single plugin
• Allow seamless switching between GUI and CLI (shared configuration and history)

Alternative Solutions

Current workarounds:

1. Using CLI exclusively:

• Works but lacks visual integration
• Context switching between terminal and IDE
• No inline diff preview
• Poor conversation management (see #[issue-number-from-previous-issue])

1. Using claude.ai/code (web version):

• Cloud-based execution environment
• Cannot access full local project with all dependencies
• Not suitable for enterprise/private codebases
• Requires internet connection and GitHub integration
• Different environment from local development setup

1. Switching to VS Code:

• Not a viable solution for developers committed to JetBrains IDEs
• Would require learning new IDE, losing JetBrains-specific features
• IntelliJ has superior support for Java/Kotlin/Spring/Android development
• Many enterprise teams standardize on JetBrains IDEs

Why alternatives don't work:

• CLI is functional but not optimal for visual code review
• Web version doesn't support full local project access
• Switching IDEs is not practical for professional developers

How other AI coding tools handle this:

• GitHub Copilot: Has plugins for both VS Code AND JetBrains IDEs
• Cursor: Built as a standalone IDE but acknowledges multiple IDE ecosystems
• Tabnine: Supports VS Code, IntelliJ, and many other IDEs
• Codeium: Has extensions for VS Code, JetBrains, and more

Priority

High - Significant impact on productivity

Feature Category

CLI commands and flags

Use Case Example

Example scenario:

1. I'm a Java/Kotlin developer working on a Spring Boot e-commerce backend in IntelliJ IDEA
2. I want Claude to help refactor authentication logic across multiple service classes
3. I invoke Claude through the sidebar panel in IntelliJ
4. Claude analyzes the code and proposes changes to 5 files:

• AuthService.java
• TokenProvider.java
• SecurityConfig.java
• UserDetailsServiceImpl.java
• JwtAuthenticationFilter.java

With IntelliJ plugin:

• Claude's panel opens in the sidebar (like Tool Windows in IntelliJ)
• I see the proposed changes with syntax-highlighted diffs
• Each file automatically opens in a diff view
• I can review each change inline, seeing the full context
• I click "Accept" for changes I approve, "Reject" for ones I don't
• Changed files are marked in the Project view
• I can continue the conversation to refine the changes
• Total time: 5 minutes of efficient, visual review

Current experience with CLI:

• Run claude in terminal, describe the task
• Claude makes changes, I see file paths in terminal output
• I manually open each file in IntelliJ
• I run git diff in terminal to see what changed
• I switch back and forth between terminal and IDE
• Visual review is fragmented and tedious
• Total time: 15 minutes with lots of context switching

Why this matters:

• IntelliJ users need the same efficient, visual experience as VS Code users
• Inline diff review is crucial for safely accepting AI-generated changes
• Integrated experience keeps developers in their IDE's context

Additional Context

Environment:

• Current CLI version: @anthropic-ai/claude-code (installed via npm)
• Platform: macOS (but plugin should be cross-platform like other JetBrains plugins)
• IDE: IntelliJ IDEA Ultimate
• Target IDEs: All JetBrains IDEs (IntelliJ IDEA, WebStorm, PyCharm, GoLand, PhpStorm, RubyMine, CLion, Rider, Android Studio)

Market Context:

JetBrains IDEs have massive market share in professional development:

• IntelliJ IDEA: Industry standard for Java/Kotlin development
• PyCharm: Popular for Python development
• WebStorm: Widely used for JavaScript/TypeScript
• Android Studio: Based on IntelliJ, required for Android development
• Enterprise adoption: Many companies standardize on JetBrains

Technical Considerations:

1. JetBrains Plugin SDK:

• Well-documented plugin development platform
• Supports all JetBrains IDEs through single codebase
• Rich APIs for editor integration, diff views, tool windows

1. Shared Backend:

• Can reuse the same Claude Code backend as CLI/VS Code
• Read from ~/.claude/settings.json and ~/.claude/history.jsonl
• Maintain compatibility with existing configurations

1. Language:

• JetBrains plugins typically use Kotlin or Java
• Can communicate with Node.js backend via IPC/HTTP

1. Distribution:

• JetBrains Marketplace for easy installation
• Similar to VS Code Marketplace for discoverability

References:

• VS Code extension documentation: https://code.claude.com/docs/en/vs-code.md
• JetBrains Plugin SDK: https://plugins.jetbrains.com/docs/intellij/welcome.html
• Example of successful multi-IDE support: GitHub Copilot, Tabnine, Codeium

Community Demand:
Many developers in enterprise environments use JetBrains IDEs and would benefit from Claude Code integration. This would significantly expand Claude Code's reach in professional development teams.

Mockup/Concept:
[A screenshot showing how it might look - similar to the VS Code extension but following IntelliJ's UI patterns: sidebar tool window with chat interface, inline diff markers in the editor, changed files
highlighted in Project view]

Thank you for considering this feature request! I believe this would make Claude Code accessible to a much broader developer audience.

Additional Context

_No response_