How to Enable Review Mode in IntelliJ IDEA: Step-by-Step
Updated Jul 2026
Some links on this page are affiliate links. If you buy through them we may earn a small commission at no extra cost to you. We only recommend what we'd use.
- Enables IntelliJ's built-in Code With Me feature for real-time reviews
- Details setup, permission controls, and session workflows
- Explains asynchronous PR review setup via the Pull Requests tool window
- Solves network, plugin, and firewall issues common during remote sessions
How to Enable Review Mode in IntelliJ IDEA: Step-by-Step
To enable live review mode in IntelliJ IDEA, click the Code With Me widget (the icon showing two people) in the top toolbar, select Start Session..., set your desired guest permissions, and send the generated link to your reviewer. For asynchronous reviews, open the Pull Requests tool window on the left sidebar to inspect diffs and leave inline comments natively inside your IDE.
What is IntelliJ Review Mode and Why Use It?
IntelliJ IDEA offers two distinct review modes: real-time collaborative editing via Code With Me, and asynchronous code review through the Pull Requests tool window. Real-time review lets developers pair-program, follow cursor movements, and debug active code together, while async mode allows inline commenting and diff inspection directly within Git branches without leaving the IDE.
Switching back and forth between a web browser and your code editor disrupts focus. Context switching loses key IDE features like jump-to-definition, type inspection, and structural search. Running reviews inside IntelliJ lets you use your custom keybindings, inspect variables, and navigate deep dependency trees during a review—capabilities that standard web interfaces simply cannot offer.
How Does Review Mode Differ from Standard Code Review?
Standard code review relies on static, post-commit diffs reviewed asynchronously through platforms like GitHub or GitLab. Real-time review mode in IntelliJ turns code analysis into an interactive session. Reviewers can execute code, set shared breakpoints, inspect state variables, and suggest edits live, drastically speeding up feedback loops on tricky implementation details.
Instead of passing code back and forth across several days of PR comments, a brief interactive session resolves architecture debates in minutes. It also helps junior developers observe how senior engineers trace bug roots, turning code reviews into active coaching sessions.
Enabling Review Mode: A Step-by-Step Guide
You can start an interactive review session in IntelliJ IDEA using the built-in Code With Me toolbar item. After launching a session, you assign guest permissions—ranging from read-only access to full editing rights—and send the session URL to your team members so they can join directly from their IDE or browser.
Modern versions of IntelliJ IDEA (2021.1 and later) bundle this feature by default. If your toolbar lacks the widget, you can enable it instantly from the plugin settings page.
Setting Up the Review Listener
To act as the session host, locate the Code With Me icon in the top-right toolbar area of IntelliJ. Select Start Session..., pick a permission preset such as Read-Only or Full Access, and click Start Session. IntelliJ generates a secure URL that you copy directly into your team chat.
Pay close attention to access levels when configuring the host session. The built-in presets allow you to grant granular permissions:
- Read-Only: Guests can navigate files and view edits, but cannot modify code or run terminal commands.
- Edit Files: Guests can edit source code and refactor files alongside you, but restricted tool windows remain hidden.
- Full Access: Guests share control over project building, running tests, and executing local terminal commands.
Joining a Review Session
Reviewers join an active session by clicking Code With Me in their IntelliJ main menu, choosing Join Session..., and pasting the host's invitation link. Guests do not need a copy of the repository; IntelliJ streams the host’s file state, syntax highlighting, and language server intelligence directly to the client.
If a reviewer does not have IntelliJ IDEA installed, clicking the link opens a download prompt for a lightweight standalone client application. This client installs quickly and provides a full editor experience without requiring a full IDE license or complex local SDK setups.
Customizing Review Mode Settings
IntelliJ allows developers to adjust review session permissions, synchronization intervals, and cursor tracking options. Under Settings > Tools > Code With Me (or Preferences on macOS), you can set default guest rights, change audio call preferences, and toggle whether guest actions trigger editor popups during busy review sessions.
Taking a few minutes to tweak these settings prevents unwanted workspace interruptions and preserves editor performance over long pairing sessions.
Synchronization Frequency and Network Usage
IntelliJ handles code synchronization over JetBrains relay servers or local network connections. While line changes sync almost instantaneously, high-latency networks may experience brief lag. Adjusting bandwidth settings and disabling automatic cursor-following reduces sync traffic, keeping the connection stable over slower internet connections or VPN setups.
To save network resources during large sessions, toggle off "Force follow guest cursors." This allows reviewers to navigate independently through distinct files in the project structure without pulling the host's active view around the workspace.
Notification Preferences
Notification controls inside Settings > Tools > Code With Me help prevent popup overload during collaborative sessions. You can configure alerts for guest connections, permission requests, and line comments. Muting trivial edit alerts keeps focus intact, while keeping security and terminal execution prompts highlighted for safety.
Hosts can also turn on explicit approval prompts for terminal operations. This ensures that any guest attempting to run shell commands on the host machine must receive explicit approval before the process executes.
Code Highlighting and Comments
During live reviews, guest cursors and selections show up as color-coded highlights across open files. For asynchronous reviews, opening the Pull Requests tool window lets you highlight specific code blocks, post inline review comments, and approve pull requests natively with full syntax highlighting and refactoring support.
When working asynchronously in the PR window, comments sync back to your code hosting service automatically. You can view existing review threads directly alongside the lines of code they reference in the editor gutter, making code updates simple to address.
Troubleshooting Common Review Mode Issues
Review mode issues typically stem from network firewalls, disabled bundled plugins, or corporate proxy restrictions. To resolve these errors, verify that the Code With Me plugin is enabled under Settings > Plugins, ensure outbound traffic to JetBrains relay servers is allowed, or configure an internal lobby server for restricted environments.
Addressing these common failure points requires basic checks of your IDE configuration and network environment.
Network Connectivity Problems
Connection drops or endless loading screens usually point to blocked TCP ports or strict VPN configurations. Ensure your network allows outbound traffic over HTTPS and WebSocket protocols. If corporate security policies block public relay servers, setting up an On-Premises Code With Me lobby server resolves regional network blocks.
Try toggling off your corporate VPN temporarily to verify whether network traffic is getting flagged by deep packet inspection systems. If the session connects over an open network, ask your system administrator to whitelist JetBrains relay endpoints.
Plugin Conflicts
Custom plugins or outdated IDE builds can cause Code With Me or Pull Request windows to freeze. Check for plugin updates via Settings > Plugins > Updates. Disabling third-party UI overlays or custom version control extensions often clears up rendering glitches during live collaborative sessions.
A good rule of thumb is testing live reviews in a clean IDE state. Disabling non-essential third-party plugins isolates whether core JetBrains features are conflicting with custom editor extensions.
Firewall Restrictions
Corporate firewalls often block direct peer-to-peer connections established during review sessions. When direct P2P connections fail, IntelliJ attempts to route connection traffic through JetBrains STUN/TURN relays. Adding rules to allow host port access or whitelisting JetBrains domain endpoints in your firewall settings ensures uninterrupted live reviews.
If direct network routing is prohibited across your company infrastructure, deploy the self-hosted Code With Me enterprise relay within your local network boundary to keep all code data behind your enterprise firewall.
Advanced Review Mode Features
Advanced review features in IntelliJ include shared debugging sessions, terminal sharing, and synchronized tool windows. These capabilities turn passive code reads into interactive sessions where hosts and reviewers can inspect call stacks, run test suites together, and execute terminal commands under monitored permission levels.
Using these tools elevates standard reviews into interactive diagnostic sessions for tough production bugs.
Shared Breakpoints
Shared breakpoints allow reviewers to place execution markers directly into the host's running code session. When the application hits a breakpoint during a joint debug run, both host and reviewer pause at the exact same line, giving both developers access to variable values and call stacks.
Reviewers can evaluate expressions in real time inside the target environment without building or running complex local application servers on their own workstation.
Collaborative Debugging
Collaborative debugging gives reviewers view or control permissions over the debug session tool window. Both participants can step over lines, evaluate expressions in the console, and inspect local variables simultaneously, making it simple to trace complex logic bugs without screen sharing.
This approach bypasses screen-share blurriness and input delay entirely. Both host and guest navigate variable trees natively inside their local IDE interface.
Comparing Review Tools: IntelliJ vs. Alternatives
Choosing the right code review tool depends on your primary IDE, security requirements, and team workflow. While IntelliJ IDEA's integrated features excel for Java and Kotlin developers who want native refactoring support, dedicated tools like Tuple or Visual Studio Live Share offer tailored advantages for non-JetBrains ecosystems.
| Tool | Best For | Pricing Tier | Standout Feature |
|---|---|---|---|
| IntelliJ Code With Me | JetBrains IDE users, Java/Kotlin teams | Bundled with IntelliJ IDEA (Community & Ultimate) | Native JetBrains AST awareness and full IDE feature access |
| Visual Studio Live Share | VS Code users, .NET and multi-language teams | Free with Microsoft Account | Seamless cross-platform pairing across VS Code and Visual Studio |
| CodeTogether | Cross-IDE teams (Eclipse, VS Code, JetBrains) | Free tier available, paid enterprise plans | Works across different IDE platforms without locking teams into one editor |
| Tuple | Low-latency, high-definition remote pair programming | Paid subscription per user | Ultra-low latency audio/video screen sharing designed specifically for coders |
🛍 Ready to buy? Check current prices on Amazon for the picks in this guide.
Here is how these review tools stack up based on practical team setups:
1. IntelliJ Code With Me: Best for teams already working inside JetBrains IDEs who want zero setup overhead and complete syntax intelligence.2. Visual Studio Live Share: The top choice if your team primarily uses VS Code or bridges frontend JavaScript and backend .NET code bases.
3. CodeTogether: Ideal for diverse development teams where members refuse to standardize on a single IDE platform.
4. Tuple: Recommended for engineering teams focused heavily on active pair-programming that require dedicated low-latency screen streaming rather than streamed editor state.
Wrapping Up: Mastering IntelliJ Review Mode
Mastering IntelliJ IDEA's review features changes how teams collaborate on code bases. Moving your reviews directly into the IDE eliminates tab switching, keeps full code navigation intact, and makes identifying edge cases far simpler. Start small by hosting a quick Code With Me session or inspecting your next GitHub pull request from the Pull Requests tool window.
- Check plugin status: Ensure Code With Me and your Git host plugins (GitHub/GitLab) are enabled under Settings.
- Start an interactive session: Use the top toolbar widget to create guest links and assign precise safety permissions.
- Adjust settings for speed: Fine-tune synchronization and notification toggles to avoid distraction during pairing.
- Fix connectivity bottlenecks: Work around firewalls by whitelisting JetBrains relay domains or hosting an internal lobby server.
- Leverage shared debugging: Debug complex features together by dropping shared breakpoints during live runs.
FAQ
How do I check if Code With Me is enabled in IntelliJ?
Open Settings > Plugins (or Preferences > Plugins on macOS), select the Installed tab, and search for "Code With Me". Ensure the checkbox beside it is checked, then click Apply and restart the IDE if prompted.
What should I do if I experience lag during a live review session?
Lower the network sync load by disabling automatic cursor-following in the session menu. Additionally, close bandwidth-heavy background applications or switch from public relay servers to a direct local network connection if both developers are on the same subnet.
Can I review code
🛍 See today's best prices on Amazon and grab the option that fits you.