Universal Entry Point: A Single Entry Point for Context-Aware Coding Assistance

Marit van Dijk

Modern IDEs are powerful tools with many useful features. When we talk about developer productivity, one thing that comes to mind is mastering the IDE – learning its features, like refactorings, navigation, or code generation, and remembering how to invoke them.

However, discovering all the relevant features of your IDE, and knowing when and how to use them can be challenging. Once you know a given feature exists, there are different ways to invoke it:

•  Shortcuts are fast, but it is hard to remember all of them.

•  Search Everywhere (⇧⇧) is great, but it pulls you out of your flow.

•  Intention actions (Alt+Enter) help, but they are discoverable only when the IDE points them out.

Our research shows that most developers can only confidently recall a few shortcuts, for example (often three or fewer). The number of useful IDE actions we need is far greater than this. When the right shortcut is hard to find or remember, we rely on menus, hints, and other visual helpers. That’s how IDEs have evolved for years: layering discoverability tools around a keyboard-driven core.

One feature every developer does use is code completion. Start typing, and the IDE suggests keywords, variables, or method names. Press the dot button (.) and see relevant API members and templates – it’s so natural that modern development feels impossible without it. Now, we aim to extend this familiar experience beyond code – to the IDE itself. This way, you can discover and execute actions the same way you complete code: context-aware, inline, and without breaking your flow.

Introducing command completion (Beta)

To help you unlock the full potential of your IDE, we are offering a universal entry point to relevant actions. 

Command completion is our attempt to provide a new way to access context-aware actions directly from your editor. It extends the existing code completion (accessible via .) that many developers are already using. Command completion works like regular completion, but in addition to classes, methods, and templates, the popup also suggests actions relevant to your current context.

• Type . to see code completion, postfix completion, and action suggestions.

• Type .. to filter completion suggestions to actions only.

• Select the action to see the exact context and preview what the action will do if applied.

To enable this Beta feature in 2025.2, go to Settings | Editor | General | Code Completion | Command Completion and select Enable command completion.

What you can do with command completion

Command completion offers you context-sensitive relevant actions. Depending on where you are in the editor, the list of suggestions may include:

• Fixes for issues – quick-fixes and warnings directly from the completion popup.

• Code transformations – actions like Introduce local variable, Reformat code, or Convert to Markdown documentation comment (Java 23+), for example.

• Refactoring and navigation – commonly used actions such as Rename or Go to declaration, as well as context-specific ones like Change signature, may appear when relevant.

• Code generation – options to generate things like constructors or getters/setters, as well as toString() or test methods.

In frameworks, IntelliJ IDEA may also suggest relevant actions (e.g. Spring bean wiring). The feature is still evolving, and more framework- and file-type support will be added. Our goal is to provide a seamless typing experience with commands in every environment, even binaries. 

How does command completion compare to existing features?

IntelliJ IDEA already has multiple ways to use existing features. Let’s see how command completion compares:

• Shortcuts – are great for speed, especially for frequently used actions, but learning shortcuts requires effort. This means there is a steep learning curve, and powerful features often go underused. The pool of meaningful key combinations is limited, and most shortcuts are not intuitive or memorable. Command completion is easier to use, since it does not require you to remember shortcuts; only the action you want to perform.
• Intention actions (Alt+Enter) – IntelliJ IDEA analyzes your code and highlights issues or improvements. Intention actions provide quick-fixes, but excessive highlighting can sometimes be distracting. Quick-fixes are reactive and limited to detected issues. Intention actions offer only a limited set of actions. Command completion offers you all the actions that are relevant to your current context. The list of actions is searchable, so you can find what you need.
• Postfix completion – Built-in templates let you quickly transform an existing expression with a single, meaningful suffix. For example,  .var transforms an existing expression into a properly declared variable, allowing you to keep moving forward when writing code. They require you to know about them, to know a template exists, or to be able to quickly find it. Command completion extends this idea to all actions, without requiring you to know the exact names of templates or commands.
• Search Everywhere (⇧⇧) – This feature allows you to find anything inside IntelliJ IDEA. However, it requires multiple steps to perform an actual action: You have to open the dialog, type the name of the desired action (which requires you to know the name), navigate the results, and confirm the action; all of which pull you out of your coding flow. More importantly, it’s detached from the current code context. Command completion keeps you in the editor, in your current context, offering only actions that are relevant there.
• Code completion – In IntelliJ IDEA, code completion will automatically appear where relevant. It can also be explicitly invoked by typing a dot (.) or the shortcut (⌃␣ on macOS) / Ctrl+Space on Windows/Linux). In addition to classes, methods, and templates, command completion adds a list of context-relevant actions. You will find them in the list of regular completion. You can filter this list to commands only, using double dot (..). You can also type ”..” anywhere in your editor to see which commands are available in that context.

Command completion is a new and complementary way to work with IntelliJ IDEA, not a replacement for existing features. It combines the speed of shortcuts with the discoverability of Search Everywhere, in an easily accessible, context-aware experience. It helps you discover relevant, powerful features, in the context where you are working. We hope it feels like a natural extension of your existing workflow and helps you to be more productive.

In short: Command completion doesn’t replace existing features – it extends and complements them. 

Why this matters

IntelliJ IDEA is designed to keep you in the coding flow. Command completion helps with this by offering the following benefits:

• Context-awareness: Suggestions adapt to where you are in your code.
• Collaboration: Easier for experienced users to guide newcomers – just type “.change signature” – no shortcut knowledge required.
• Consistency: Works across different keymaps, OSes, and workflows.
• Discoverability: See what actions are possible without leaving the editor.

Command completion allows you to think about what you want to achieve, instead of how to do so. This will also make pair programming easier, as you only need to describe what you want to do without having to interrupt your flow to find how to do it.  

Looking ahead

Command completion is still in Beta, with improvements ongoing. At the moment, we have support for Java and Kotlin, as well as a few framework-specific actions that are also provided as intention actions, like Autowire Bean when you are using Spring Framework, or Extract JPQL Query for a Spring Data repository. More actions, file types, and framework-specific commands will appear in future releases, not only for Spring, but also for Hibernate and other frameworks. 

For example, in the 2025.3 EAP, you can already navigate read-only files with .., Go to Declaration, or Go to Implementation – even in external libraries. Also in 2025.3 EAP, commands come with aliases, so you don’t have to remember the exact names. We are also planning to add the option to add your own actions to command completion. Finally, we’re exploring integration with AI, so you could type things like “.suggest better name” or “.explain this”.

Initial feedback

We very much appreciate your feedback and will be using it to guide the development process. So far, our first Beta users have indicated that the feature is promising. 

A lot of comments were provided under the What’s New in IntelliJ IDEA 2025.2 livestream where the command completion (Beta) feature was introduced:

We have also received some direct feedback on LinkedIn and other Social Media: 

Try it out: Go to Settings, enable Command Completion, type . in the editor, and explore. You might discover powerful IDE features you never knew were there!

Please let us know what you think. We would love to hear how you are using command completion in your daily work and what we could add to make it even better. Thank you!

Subscribe to IntelliJ IDEA Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!