Integrated Development Environments (IDEs) have played a crucial role in shaping the way software is developed. Engineering Practices such as Agile development, eXtreme Programming, Test-Driven Development (TDD), became practical largely because IDEs provided a visual and integrated workflow for writing and managing code.

In the early days, developers interacting heavily on command-line. Formatting code, navigating files, searching references, and refactoring logic were mostly manual tasks. Over time, IDEs transformed this experience. They began performing continuous static analysis, making searching, referencing, duplication detection, and issue discovery significantly faster. Refactoring also became easier. Because of this, practices like the Red–Green–Refactor cycle in TDD became far more practical to follow in everyday development.

Without IDEs, many engineering practices would have remained theoretical rather than widely adopted. IDEs bring together various aspects of development into one unified workspace — editors, database viewers, debuggers, test runners, and more — along with visualizations that help developers reason about their systems.

This is why, even though we talk extensively about AI-assisted software development, the real impact will only emerge when AI is deeply integrated into the IDE itself.

Over the past few years, AI integrations within IDEs have improved rapidly. Developers can now chat with their IDEs, generate code, refactor existing logic, diagnose issues, and automate tasks directly from within the development environment.

In this article, we will explore how to integrate Claude Code with IntelliJ IDEA and see how it can assist with refactoring, bug fixing, and developer productivity.

Install Claude Code

Install Claude Code as described in the official documentation: https://code.claude.com/docs/en/quickstart

brew install --cask claude-code

Install Claude Code Plugin in IntelliJ

Next, install the Claude Code plugin in IntelliJ IDEA. Navigate to:

Settings → Plugins → Claude Code [Beta] → Install

or install directly from the JetBrains marketplace: https://plugins.jetbrains.com/plugin/27310-claude-code-beta-

Restart the IDE after installation.

Integrating Claude Code in a Project

Open your project in IntelliJ and launch the integrated terminal. Then run:

sdui-client > claude

This will start the Claude CLI. The first step is to log in to your Claude account.

❯ /login                                                                                                                                                                                                   
  ⎿  Login successful

Choose your preferred login method. Your browser will open for authentication. Once logged in, return to the terminal. Next, connect Claude to IntelliJ:

❯ /ide                                                                                                                                                                                                     
  ⎿  Connected to IntelliJ IDEA.

At this point, your IDE is successfully integrated with Claude Code.

Set the Project Context

Claude works best when it understands your project context. This is done through a CLAUDE.md file. If the file does not exist, you can ask Claude to generate one automatically:

❯ /init   

Write(CLAUDE.md)
  ⎿ Wrote 69 lines to CLAUDE.md

Claude will continuously use this file as context for future tasks within the project.

Ask the IDE to Perform Tasks

Now we can ask the IDE to perform real development tasks.

For example, I asked it to:

❯ write unit tests for core rendering logic and also integrate with code coverage tool, and report it.

Claude begins exploring the project structure:

 Explore(Explore client test structure)
  ⎿ Done (23 tool uses · 27.6k tokens · 39s)

It then proposes a plan:

⏺ Now I have everything I need. Here's the plan:
  1. Extract a UiDataSource interface to enable dependency injection into LandingViewModel
  2. Add coroutines-test + Kover (JetBrains' Kotlin coverage tool) to the build
  3. Write serialization tests for the model and logic tests for the ViewModel

Claude proceeds to implement the plan:

⏺ Write(composeApp/src/commonMain/kotlin/com/thinkuldeep/sdui/client/data/UiDataSource.kt)
  ⎿ Wrote 7 lines to composeApp/src/commonMain/kotlin/com/thinkuldeep/sdui/client/data/UiDataSource.kt
....

During the process, it asks for approvals before modifying files, adding dependencies, or executing commands.

Eventually it:

• Made the code more testable
• Added mocking libraries
• Removed placeholder tests
• Generated new unit tests
• Integrated code coverage tooling
• Produced a coverage report

Not just that, I asked it to commit the code and push the changes, and it did wonder.

❯ commit the changes                                                                                                                                                                                       
⏺ Bash(git status && git diff --stat)
  ⎿ On branch main
     Your branch is up to date with 'origin/main'.
     … +24 lines (ctrl+o to expand)
⏺ Bash(git commit -m "$(cat <<'EOF'
      Add unit tests with 100% code coverage and Kover integration…)
  ⎿ [main afdda43] Add unit tests with 100% code coverage and Kover integration
      11 files changed, 558 insertions(+), 19 deletions(-)
      create mode 100644 sdui-client/CLAUDE.md
     … +5 lines (ctrl+o to expand)

⏺ Committed as afdda43.

❯ push it                                                                                                                                                                                                  
⏺ Bash(git push)
  ⎿ To github.com:thinkuldeep/SDUIPractices.git
        28a3437..afdda43  main -> main
⏺ Pushed to origin/main. 

Find the commit hash here

Try More Tasks

You can now experiment with different tasks:

• Ask it to fix a bug reported by QA
• Implement a new feature or user story
• Refactor complex code
• Improve test coverage
• Generate documentation

Pretty cool, right?

What’s Next?

While this might look impressive, an important question remains:

How do you trust the code generated by AI?

AI tools should be treated as assistants, not autonomous developers. Always review the generated code carefully. Developers must remain strong reviewers and maintain engineering discipline.

Also remember — nothing comes without a cost.

Track your cost!

AI agents consume tokens, which directly translate to usage costs.

 /cost                                                                                                                                                                                                    
  ⎿  Total cost:            $6.61
     Total duration (API):  17m 13s                                                                                                                                                                        
     Total duration (wall): 13h 58m 28s                                                                                                                                                                  
     Total code changes:    575 lines added, 36 lines removed                                                                                                                                              
     Usage by model:                                                                                                                                                                                       
        claude-sonnet-4-6:  85 input, 53.3k output, 4.0m cache read, 490.3k cache write ($6.39)                                                                                                            
         claude-haiku-4-5:  624 input, 13.1k output, 647.9k cache read, 65.4k cache write ($0.2129) 

Optimise Token Usage

You may have noticed there were information on tokens being used while IDE following your commands.

Tokens are the new currency in AI-assisted development. Use them wisely.

Follow the reduce token usages guidelines.

• Provide compact instructions
• Choose the right model for the task
• Manage the context size
• Use skills for reusable knowledge

Best Practices

Follow the Claude Code Best Practices here

Extend it

Skills, Hooks, MCP and more Provide your rules, reusable aspect, clear instrcutuions. Break them in domains.

Next Article

In the next article, we will explore:

• Claude Skills
• Context management strategies
• Creating reusable AI workflows in development
• Building a true AI-native development environment

Stay tuned!