Set Up Qodo AI in JetBrains IDEs

Why set up Qodo AI in JetBrains IDEs

JetBrains IDEs are the dominant development environment for Java, Kotlin, Python, and web development teams. IntelliJ IDEA alone holds a commanding share of the Java IDE market, and PyCharm is the most popular dedicated Python IDE. If your team develops in any of these ecosystems, you are almost certainly running a JetBrains IDE - and integrating AI-powered code review and test generation directly into that environment is the fastest way to catch bugs, improve code quality, and ship with better test coverage.

Qodo (formerly CodiumAI) is an AI code quality platform that brings automated code review, test generation, and quality analysis into your editor. Unlike tools that only operate at the pull request level, the Qodo JetBrains plugin lets you review code and generate tests locally before you commit, creating a shift-left workflow where issues are caught at the earliest possible stage. The plugin supports multiple AI models including GPT-4o, Claude 3.5 Sonnet, and DeepSeek-R1, and even offers local LLM support through Ollama for teams that need to keep all code processing on their own infrastructure.

This guide covers the complete setup process for the Qodo AI plugin across IntelliJ IDEA, PyCharm, and WebStorm - from installation and authentication to test generation, code review, configuration, keyboard shortcuts, and troubleshooting. Everything described here works on both the free Developer plan (250 credits per month) and the paid Teams plan ($30/user/month with 2,500 credits). If you are looking for the VS Code version instead, see Qodo VS Code setup.

Prerequisites

Before installing the Qodo plugin, confirm your environment meets these requirements:

• JetBrains IDE version 2023.1 or later - the Qodo plugin requires a relatively recent IDE version. Check your version under Help, then About (IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, PhpStorm, CLion, or RubyMine all work)
• An active internet connection - required for plugin download and authentication; also required for cloud-based AI model access unless you configure a local LLM
• A Qodo account - you can sign up for free at qodo.ai using GitHub, GitLab, Google, or email
• At least one project open in your IDE - not strictly required for installation, but you will need a project to test the plugin's features

If you do not yet have a Qodo account, you will be able to create one during the authentication step after installing the plugin.

Step 1: Install the Qodo plugin from the JetBrains Marketplace

The Qodo plugin installs directly from the built-in Marketplace inside your JetBrains IDE. There is no need to download files externally or configure repositories.

Installation in IntelliJ IDEA

1. Open IntelliJ IDEA
2. Go to Settings by pressing Ctrl+Alt+S on Windows/Linux or Cmd+, on macOS
3. Select Plugins from the left sidebar
4. Click the Marketplace tab at the top
5. Type Qodo in the search bar
6. Locate Qodo Gen in the search results (published by Qodo, formerly listed as CodiumAI)
7. Click Install
8. Wait for the download and installation to complete
9. Click Restart IDE when prompted

After the restart, the Qodo icon appears in the right sidebar of your IDE. This icon opens the Qodo tool window where you will authenticate and interact with the AI assistant.

Installation in PyCharm

The process in PyCharm is identical:

1. Open PyCharm (Community or Professional edition)
2. Navigate to Settings (Ctrl+Alt+S or Cmd+,)
3. Go to Plugins, then the Marketplace tab
4. Search for Qodo
5. Install Qodo Gen and restart PyCharm

PyCharm Community edition fully supports the plugin. You do not need PyCharm Professional for Qodo functionality.

Installation in WebStorm

WebStorm follows the same process:

1. Open WebStorm
2. Open Settings (Ctrl+Alt+S or Cmd+,)
3. Navigate to Plugins, then Marketplace
4. Search for and install Qodo Gen
5. Restart WebStorm

Installation in other JetBrains IDEs

The Qodo plugin works across the entire JetBrains product line. GoLand, Rider, PhpStorm, CLion, and RubyMine all use the same installation flow. Search for "Qodo" in the Plugins Marketplace of any supported IDE, install it, and restart.

Alternative: Install from the JetBrains Marketplace website

If you prefer to browse plugins outside the IDE:

1. Visit the JetBrains Marketplace in your browser
2. Search for Qodo Gen
3. Click Install to IDE and select your installed JetBrains IDE from the list
4. Your IDE opens with the installation prompt - confirm the install and restart

This method is useful when you want to check plugin reviews, version history, or compatibility information before installing.

Step 2: Authenticate your Qodo account

After installation and restart, you need to sign in to connect the plugin to your Qodo account. Authentication links the plugin to your credit balance, team settings, and model preferences.

1. Click the Qodo icon in the right sidebar of your IDE to open the Qodo tool window
2. Click Sign In (or "Get Started" if this is your first time)
3. A browser window opens automatically, directing you to the Qodo authentication page
4. Choose your sign-in method:
   • GitHub - recommended if you also use Qodo for PR reviews on GitHub
   • GitLab - for GitLab-based workflows
   • Google - for quick sign-in with your Google account
   • Email - create a standalone Qodo account with email and password
5. Complete the authentication in the browser
6. The browser displays a confirmation message, and the IDE plugin automatically receives the authentication token

After successful authentication, your account name and remaining credits appear in the Qodo panel. If the automatic browser redirect does not work (common in some corporate network environments), click the "Copy Token" link in the browser and paste the token into the prompt that appears in the IDE.

Verifying authentication

To confirm that authentication is working properly:

1. Open a source code file in your editor
2. Select a function or code block
3. Right-click and look for Qodo options in the context menu

If you see options like "Qodo: Generate Tests" and "Qodo: Review Code," authentication is active and the plugin is ready to use.

Step 3: Generate tests with Qodo

Test generation is Qodo's signature feature and the primary reason many developers install the plugin. Unlike generic AI coding assistants that produce boilerplate tests, Qodo analyzes your code's behavior, identifies untested logic paths, and generates framework-appropriate tests with meaningful assertions.

Generating tests for a function

1. Open a source file containing the function you want to test
2. Place your cursor inside the function or select its entire body
3. Right-click and choose Qodo: Generate Tests from the context menu, or press Alt+Shift+T (Windows/Linux) or Option+Shift+T (macOS)
4. Qodo analyzes the function's signature, logic branches, edge cases, and dependencies
5. Generated tests appear in the Qodo panel, where you can review, edit, and accept them

Test generation for Java in IntelliJ

For Java projects, Qodo generates JUnit 5 tests by default. Here is an example of what to expect:

// Your source code
public class OrderService {
    public double calculateDiscount(Order order, Customer customer) {
        if (customer.isPremium() && order.getTotal() > 100) {
            return order.getTotal() * 0.15;
        }
        if (order.getTotal() > 200) {
            return order.getTotal() * 0.10;
        }
        return 0;
    }
}

Qodo identifies the branching logic and generates tests covering each path:

@Test
void calculateDiscount_premiumCustomerAbove100_returns15Percent() {
    // ...
}

@Test
void calculateDiscount_nonPremiumAbove200_returns10Percent() {
    // ...
}

@Test
void calculateDiscount_nonPremiumBelow200_returnsZero() {
    // ...
}

@Test
void calculateDiscount_premiumCustomerBelow100_returnsZero() {
    // ...
}

Test generation for Python in PyCharm

For Python projects, Qodo generates pytest tests by default, respecting your project's testing conventions:

# Your source code
def parse_config(filepath: str) -> dict:
    if not os.path.exists(filepath):
        raise FileNotFoundError(f"Config not found: {filepath}")
    with open(filepath) as f:
        data = json.load(f)
    if "version" not in data:
        raise ValueError("Missing required 'version' key")
    return data

Qodo generates tests that cover the happy path, missing file, invalid JSON, and missing key scenarios - edge cases that developers often skip during manual test writing.

Using the /test command in chat

You can also generate tests through the Qodo chat panel:

1. Open the Qodo chat panel from the right sidebar
2. Type /test followed by a description of what you want to test
3. Qodo generates tests based on the currently open file or selected code

The chat-based approach is useful when you want to specify additional context, like "generate tests that cover concurrent access scenarios" or "focus on error handling paths."

Accepting and saving generated tests

After Qodo generates tests, you have several options:

• Accept All - creates the test file in your project's test directory following your project's directory conventions
• Accept Selected - choose specific test methods to include
• Edit - modify generated tests before saving
• Regenerate - request a new set of tests if the initial generation is not satisfactory

Generated tests are saved to your project's standard test directory. For Maven projects, that is src/test/java. For Python projects, Qodo follows the convention of your existing test files or places them in a tests directory.

For more details on Qodo's test generation capabilities, see our Qodo test generation deep dive.

Step 4: Use code review features

The Qodo plugin provides on-demand code review directly inside your editor, allowing you to get AI feedback on your code before committing or opening a pull request. This complements Qodo's PR-level review by catching issues earlier in the development cycle.

Reviewing selected code

1. Select a block of code in your editor - this can be a function, a class, or any arbitrary selection
2. Right-click and choose Qodo: Review Code or press Alt+Shift+R (Windows/Linux) or Option+Shift+R (macOS)
3. Qodo analyzes the selected code for:
   • Bugs and logic errors - null pointer risks, off-by-one errors, race conditions
   • Security vulnerabilities - SQL injection, path traversal, hardcoded secrets
   • Code quality issues - excessive complexity, code duplication, unclear naming
   • Best practice violations - framework-specific anti-patterns, deprecated API usage
4. Results appear in the Qodo panel with severity indicators, explanations, and suggested fixes

Reviewing entire files

To review a complete file, open it in the editor and use the /review command in the Qodo chat panel. This analyzes the entire file and provides a summary of findings organized by severity.

Inline annotations

When Qodo identifies issues, it can display inline annotations directly in the editor gutter. These annotations use color-coded severity markers:

• Red - critical and high severity issues that should be fixed before committing
• Yellow - medium severity issues that are worth addressing
• Blue - low severity suggestions for improvement

Click any annotation to see the full explanation and suggested fix in the Qodo panel.

Using code review with the chat panel

The Qodo chat panel supports natural language interactions for code review:

• Ask "What are the potential issues in this function?" with code selected
• Request "Review this class for thread safety" for concurrency-focused analysis
• Type "Are there any security issues in the selected code?" for security-focused review

The conversational interface makes it easy to iterate on findings and ask follow-up questions about specific issues.

For a comprehensive review of Qodo's capabilities, read our full Qodo review.

Step 5: Configure the Qodo plugin settings

Qodo's plugin settings let you customize the AI model, behavior, and integration preferences to match your workflow. Access the settings through the gear icon in the Qodo panel or through your IDE's Settings menu under Tools, then Qodo.

Model configuration

Qodo supports multiple AI models, each with different strengths and credit costs:

Model	Credits per request	Best for
GPT-4o	1	General code review and chat
Claude 3.5 Sonnet	1	Detailed explanations and complex analysis
Claude Opus	5	Most thorough analysis, complex codebases
DeepSeek-R1	1	Cost-effective analysis
Grok 4	4	Broad knowledge, alternative perspective

Select your preferred model in the Qodo settings panel. You can switch models at any time without restarting the IDE. For most developers, GPT-4o or Claude 3.5 Sonnet at 1 credit per request provides the best balance of quality and credit efficiency.

Privacy and data settings

If your organization has strict data handling requirements, configure the following:

• Telemetry - disable anonymous usage data collection if required by your organization's policies
• Code snippets in prompts - Qodo sends selected code to its cloud API for analysis by default. For sensitive codebases, consider using the Ollama integration for local processing

Ollama integration for local LLMs

To run all AI analysis locally without sending code to external servers:

1. Install Ollama on your machine
2. Pull a supported model: ollama pull codellama or ollama pull mistral
3. Open Qodo settings in your JetBrains IDE
4. Under Model Provider, select Ollama
5. Set the endpoint to http://localhost:11434
6. Select your downloaded model from the dropdown

All subsequent Qodo operations will run locally. Response times depend on your hardware - a machine with a dedicated GPU provides significantly faster inference than CPU-only processing.

Project-specific settings

Qodo can be configured per project. Create a .qodo configuration file in your project root to set:

• Preferred testing frameworks and conventions
• Custom review instructions for your codebase
• File and directory exclusions
• Language-specific analysis preferences

Step 6: Learn the keyboard shortcuts

Keyboard shortcuts turn Qodo from a panel-based tool into an integrated part of your editing flow. Learning these shortcuts eliminates the need to use context menus or click through the Qodo panel for common operations.

Default shortcuts

Action	Windows/Linux	macOS
Open Qodo Chat	Alt+Shift+C	Option+Shift+C
Generate Tests	Alt+Shift+T	Option+Shift+T
Review Code	Alt+Shift+R	Option+Shift+R

Customizing shortcuts

If the default shortcuts conflict with other plugins or your personal keybindings:

1. Open Settings (Ctrl+Alt+S or Cmd+,)
2. Navigate to Keymap
3. Search for Qodo in the search field
4. All registered Qodo actions appear in the list
5. Double-click any action to assign a new shortcut
6. Click OK to save

Custom shortcuts persist across IDE restarts and plugin updates. They are stored in your IDE's keymap configuration, not in the plugin itself.

Context menu actions

In addition to keyboard shortcuts, Qodo adds the following actions to the editor context menu (right-click menu):

• Qodo: Generate Tests - generates tests for the selected code
• Qodo: Review Code - reviews the selected code for issues
• Qodo: Explain Code - provides a detailed explanation of the selected code
• Qodo: Improve Code - suggests improvements to the selected code

These context menu items appear when you right-click inside a code editor with code selected.

Step 7: Use the Qodo chat panel for advanced workflows

The Qodo chat panel is a conversational interface that supports slash commands and natural language queries beyond simple code review and test generation.

Available slash commands

Command	Description
/test	Generate tests for selected or described code
/review	Review code for bugs, security, and quality
/explain	Explain what selected code does
/improve	Suggest improvements to selected code
/docstring	Generate documentation for selected code

Multi-turn conversations

The chat panel maintains context within a conversation, so you can ask follow-up questions:

1. Select a function and type /review
2. After seeing the review results, ask "How would I fix the null pointer issue you mentioned?"
3. Follow up with "Can you generate a test that catches this bug?"

This conversational workflow lets you move from identifying problems to implementing solutions without switching tools.

Code generation and refactoring

Beyond review and testing, the chat panel supports general code assistance:

• "Refactor this method to use the builder pattern"
• "Add proper error handling to this function"
• "Convert this callback-based code to use async/await"

Qodo generates the refactored code in the chat panel where you can review it before applying changes to your file.

Integrating Qodo with your team workflow

For maximum value, combine the Qodo JetBrains plugin with Qodo's PR-level review. This creates a two-layer quality gate where issues are caught first in the developer's IDE and again during the pull request review.

The shift-left workflow

1. Write code in IntelliJ, PyCharm, or WebStorm
2. Generate tests with Qodo before committing - this ensures new code ships with test coverage
3. Review locally with Qodo to catch bugs and security issues before pushing
4. Open a pull request - Qodo's PR review agent provides a second, independent analysis of the diff
5. Address findings from both IDE and PR review before merging

This workflow catches different types of issues at each stage. The IDE plugin catches problems in the context of the full file, while the PR review catches problems specific to the diff and its impact on the broader codebase.

Credit management for teams

On the free Developer plan, each team member gets 250 IDE credits per month. For a team of five developers, that is 1,250 total monthly IDE interactions across the team. If your team finds itself running low on credits regularly, the Teams plan at $30/user/month increases the allocation to 2,500 credits per user.

Monitor your credit usage in the Qodo panel - your remaining balance is displayed in the bottom section of the tool window.

CodeAnt AI as an alternative

If your team needs a broader code quality platform that bundles code review with SAST, secret detection, and engineering metrics, consider CodeAnt AI as an alternative. CodeAnt AI is a Y Combinator-backed platform that combines AI-powered PR reviews with static analysis security scanning (OWASP Top 10), secret detection for API keys and tokens, infrastructure-as-code security scanning, dead code detection, and DORA metrics dashboards.

CodeAnt AI pricing starts at $24/user/month for the Basic plan (AI PR reviews with line-by-line feedback across 30+ languages) and $40/user/month for the Premium plan (adds SAST, secrets, IaC scanning, and DORA metrics). While CodeAnt AI does not offer a JetBrains plugin - its strength is in PR-level review and security scanning - teams that need security scanning alongside code review may find it a more cost-effective option than running Qodo plus a separate security tool.

The key trade-off is specialization versus breadth. Qodo excels at test generation and in-IDE development workflows. CodeAnt AI excels at combining code review with security scanning and engineering metrics in a single platform. For a deeper look at options, see our Qodo alternatives comparison.

Troubleshooting common issues

Even with a straightforward plugin installation, you may encounter issues. Here are the most common problems and their solutions.

Plugin not appearing after installation

Problem: You installed the Qodo plugin but the icon does not appear in the sidebar.

Fix: Restart your IDE. JetBrains plugins require a restart to activate. If the icon still does not appear after restart, go to Settings, then Plugins, then the Installed tab, and verify that Qodo Gen is listed and has a checkmark (enabled). If it is listed but disabled, enable it and restart again. For persistent issues, try File, then Invalidate Caches / Restart to clear the IDE cache completely.

Authentication fails or browser redirect does not work

Problem: Clicking "Sign In" opens the browser but the IDE does not receive the authentication token.

Fix: This is common in corporate environments with proxy servers or strict firewall rules. After authenticating in the browser, look for a "Copy Token" or "Manual Authentication" link on the success page. Copy the token and paste it into the authentication prompt in your IDE. If no prompt appears, check the Qodo settings panel for a field to manually enter the authentication token.

"No credits remaining" error

Problem: Qodo displays a credit exhaustion message when you try to use any feature.

Fix: The free Developer plan includes 250 credits per month. Credits reset 30 days from your first message, not on a calendar schedule. Check your remaining balance in the Qodo panel. If you need more credits, the Teams plan at $30/user/month provides 2,500 credits. Also note that premium models consume multiple credits per request - switching from Claude Opus (5 credits) to GPT-4o (1 credit) stretches your balance significantly. See Qodo pricing for a full breakdown.

Plugin conflicts with other AI assistants

Problem: The Qodo plugin conflicts with GitHub Copilot, JetBrains AI Assistant, or another AI plugin, causing duplicate suggestions or keyboard shortcut conflicts.

Fix: Qodo's keyboard shortcuts may overlap with other plugins. Go to Settings, then Keymap, and search for the conflicting shortcut to reassign it. Qodo and Copilot can coexist without issues since they serve different purposes - Copilot provides inline code completion while Qodo provides code review and test generation. If you experience performance issues with multiple AI plugins active, disable background analysis in Qodo settings and trigger analysis manually.

Slow test generation or review responses

Problem: Qodo takes a long time to generate tests or review code, especially for large files.

Fix: Response time depends on the selected AI model, code complexity, and network latency. Try these steps:

1. Select a smaller code block rather than an entire class - Qodo provides better results when focused on specific functions
2. Switch to a faster model like GPT-4o if you are using a premium model
3. Check your network connection - each request sends code to Qodo's cloud API (unless using Ollama)
4. For very large files, break the review into multiple smaller selections

Generated tests use the wrong framework

Problem: Qodo generates JUnit 4 tests when your project uses JUnit 5, or generates unittest tests when you use pytest.

Fix: Qodo detects your testing framework from your project's dependencies and existing test files. If detection fails, specify the framework explicitly in the /test command: "/test using pytest" or "/test with JUnit 5." You can also set the default framework in the Qodo settings panel under Test Generation preferences.

IDE becomes unresponsive

Problem: Your JetBrains IDE becomes slow or unresponsive after installing Qodo.

Fix: Disable Qodo's background analysis in the plugin settings so that analysis only runs when you explicitly trigger it. Additionally, increase the IDE's memory allocation by editing the .vmoptions file:

1. Go to Help, then Edit Custom VM Options
2. Change -Xmx from the default (usually 2048m) to 4096m or higher:

   -Xmx4096m

1. Restart the IDE

If the problem persists after increasing memory, try disabling other memory-intensive plugins temporarily to identify the source of the slowdown.

What to do after setup

With the Qodo plugin installed and configured in your JetBrains IDE, here is how to get the most value from it:

1. Start with test generation - pick a critical function in your codebase that lacks test coverage and generate tests for it. This is the fastest way to see Qodo's value and the feature that most differentiates it from other AI tools
2. Run a code review on a module you are actively working on - the review will likely surface issues you had not considered, giving you an immediate sense of the plugin's analytical depth
3. Install the Qodo PR review app on your GitHub, GitLab, or Bitbucket account to complement the IDE plugin with automated PR-level review. Read our Qodo review for details on the PR review setup
4. Configure keyboard shortcuts to match your muscle memory - developers who rely on shortcuts rather than menus integrate Qodo into their workflow significantly faster
5. Set up a local LLM via Ollama if your team handles sensitive code - this eliminates any concern about code leaving your machine

The combination of IDE-level test generation and code review with PR-level automated review gives you two independent quality gates. Issues caught early in the IDE cost less to fix than issues caught during PR review, and issues caught during PR review cost less than issues found in production. By the time code is merged, it has been analyzed twice by different Qodo components, significantly reducing the chance of shipping bugs or security vulnerabilities.

For teams evaluating Qodo against other options, see our Qodo alternatives comparison. For pricing details and plan recommendations, check the Qodo pricing breakdown.

Further Reading

• Qodo Merge GitHub Integration: Automated PR Review Setup
• Best AI Code Review Tools in 2026 - Expert Picks
• Best AI Code Review Tools for Pull Requests in 2026
• Best AI Test Generation Tools in 2026: Complete Guide
• CodiumAI Alternatives: Best AI Tools for Automated Testing in 2026

Frequently Asked Questions

How do I install Qodo AI in IntelliJ IDEA?

Open IntelliJ IDEA and navigate to Settings (Ctrl+Alt+S on Windows/Linux or Cmd+, on macOS), then go to Plugins and click the Marketplace tab. Search for 'Qodo' in the search bar and click Install on the Qodo Gen plugin. Restart IntelliJ when prompted. After restart, the Qodo icon appears in the right sidebar. Click it to open the Qodo panel and sign in with your GitHub, GitLab, or Google account. The plugin works with IntelliJ IDEA Community and Ultimate editions, including versions 2023.1 and later.

Does the Qodo plugin work in PyCharm and WebStorm?

Yes. The Qodo plugin is compatible with all JetBrains IDEs that support third-party plugins, including IntelliJ IDEA, PyCharm (Community and Professional), WebStorm, GoLand, Rider, PhpStorm, CLion, and RubyMine. The installation process is identical across all JetBrains IDEs - search for Qodo in the Plugins Marketplace, install it, and restart the IDE. Feature availability is the same regardless of which JetBrains IDE you use.

Is the Qodo JetBrains plugin free?

Yes. The Qodo JetBrains plugin is free to install and use. The free Developer plan includes 250 credits per calendar month for IDE and CLI interactions, which covers most individual developer usage. Standard operations consume 1 credit each, though premium models like Claude Opus cost 5 credits per request and Grok 4 costs 4 credits per request. Credits reset every 30 days from your first message. The Teams plan at $30 per user per month increases the allowance to 2,500 credits per month.

How do I generate tests with Qodo in JetBrains?

Select a function or class in your editor, right-click, and choose 'Qodo: Generate Tests' from the context menu. Alternatively, use the /test command in the Qodo chat panel. Qodo analyzes the selected code, identifies edge cases and error scenarios, and generates test files in your project's testing framework such as JUnit for Java, pytest for Python, or Jest for JavaScript. You can also highlight code and use the keyboard shortcut Alt+Shift+T (Windows/Linux) or Option+Shift+T (macOS) to trigger test generation directly.

How do I authenticate the Qodo JetBrains plugin?

After installing the plugin, click the Qodo icon in the right sidebar of your JetBrains IDE. Click 'Sign In' and a browser window opens with the Qodo authentication page. Choose your preferred sign-in method - GitHub, GitLab, Google, or email. After authenticating in the browser, the token is automatically passed back to the IDE. You should see your account name appear in the Qodo panel, confirming successful authentication. If the browser redirect fails, you can copy the authentication token manually from the browser and paste it into the IDE when prompted.

What keyboard shortcuts does Qodo use in JetBrains?

Qodo registers several keyboard shortcuts in JetBrains IDEs. Alt+Shift+C (Windows/Linux) or Option+Shift+C (macOS) opens the Qodo chat panel. Alt+Shift+T or Option+Shift+T triggers test generation for selected code. Alt+Shift+R or Option+Shift+R starts an inline code review. You can customize all shortcuts by going to Settings, then Keymap, and searching for 'Qodo' to see and rebind all registered actions. Custom shortcuts persist across IDE restarts and updates.

Can I use Qodo with a local LLM in JetBrains instead of cloud models?

Yes. Qodo supports local LLM execution through Ollama integration. Install Ollama on your machine, pull a supported model like CodeLlama or Mistral, and then open Qodo Settings in your JetBrains IDE. Under the Model Provider section, select 'Ollama' and specify the local endpoint (typically http://localhost:11434). All code analysis then runs locally without sending any code to external servers. This is particularly useful for teams in regulated industries or working on proprietary codebases where cloud-based code analysis is not permitted.

Why is the Qodo plugin not appearing after installation in JetBrains?

The most common cause is skipping the IDE restart. After installing the Qodo plugin, you must restart IntelliJ, PyCharm, or whichever JetBrains IDE you are using. If the plugin still does not appear after restart, check that the plugin is enabled by going to Settings, then Plugins, then the Installed tab, and verifying that Qodo Gen has a checkmark. Also confirm your IDE version is 2023.1 or later, as older versions are not supported. If problems persist, uninstall the plugin, clear the IDE cache via File then Invalidate Caches, restart, and reinstall from the Marketplace.

How do I use Qodo for code review inside JetBrains?

Open the file you want to review in your JetBrains editor and select the code block you want analyzed. Right-click and choose 'Qodo: Review Code' from the context menu, or use the Alt+Shift+R shortcut. Qodo analyzes the selected code for bugs, security issues, code quality problems, and best practice violations. Results appear in the Qodo panel with explanations and suggested fixes. You can also use the /review command in the Qodo chat panel to review an entire file or paste a code snippet for analysis.

Does Qodo slow down JetBrains IDE performance?

Qodo runs its analysis asynchronously and does not block the main IDE thread, so it should not cause noticeable lag during editing, navigation, or compilation. However, some users report slower response times on very large codebases exceeding 100,000 lines of code, particularly during test generation for complex classes with many dependencies. If you experience sluggishness, try disabling background analysis in Qodo settings and running analysis manually instead. Allocating more memory to your JetBrains IDE through the vmoptions file can also help.

Can I configure Qodo to use a specific AI model in JetBrains?

Yes. Open the Qodo settings panel in your JetBrains IDE and navigate to the Model Configuration section. You can select from available models including GPT-4o, Claude 3.5 Sonnet, Claude Opus, DeepSeek-R1, and others. Different models have different credit costs - standard models consume 1 credit per request while premium models like Claude Opus cost 5 credits. The model selection applies to all Qodo operations in the IDE including chat, code review, and test generation. You can switch models at any time without restarting the IDE.

What is the difference between Qodo in JetBrains and Qodo PR review on GitHub?

The Qodo JetBrains plugin and the Qodo PR review on GitHub serve different stages of the development workflow. The JetBrains plugin provides local, pre-commit analysis - you review code and generate tests before pushing changes. It uses your IDE credits (250 free or 2,500 on Teams). The GitHub PR review activates after you open a pull request and provides automated review comments on the diff using your PR review quota (30 free or unlimited on Teams). Using both together creates a shift-left workflow where issues are caught locally in the IDE and again during PR review, reducing the number of problems that reach production.

---

Originally published at aicodereview.cc