We are continually looking for ways to reduce friction in the developer workflow and consistently hear that developers experience friction when writing long, paragraph-style prompts. This process often feels unnatural to engineers and disrupts their workflow by forcing them out of the editor. Furthermore, a single prompt is often insufficient for guiding large-scale or multi-step changes, leading to a frustrating cycle of trial and error. At the same time, deciphering complex or unfamiliar codebases remains a time-consuming challenge, often bottlenecked by missing or outdated documentation.
To solve these developer friction points, we are introducing two new features to the Gemini Code Assist extensions for IntelliJ and Visual Studio Code: Finish Changes and Outlines. Powered by Gemini 3.0, these tools shift the AI interaction model from tedious prompt engineering to seamless, contextual in-editor programming.
Finish Changes: Show, Don’t Tell
Finish Changes acts like an AI pair programmer, without requiring you to write a prompt. It observes your in-progress code modifications and uses Gemini 3.0 to complete the intended task. By synthesizing your holistic intent from partial code, pseudocode, and comments, you can stay completely within the editor and maintain your flow state.
This “show, don’t tell” approach natively supports several core workflows:
- Implementing Pseudocode: You can write a high-level pseudocode sketch and have the Gemini fill in the detailed implementation. No need to worry about syntax details — even plain English is fine!
- Applying Patterns: Some repetitive code changes are tricky to explain clearly with just words. You can demonstrate a repetitive change once, and Gemini applies that pattern everywhere else it is needed in the file.
- Following Instructions: You can write instruction commands just like prompting a chatbot by writing a
// TODO: <instruction> or //! <instruction>comment directly in your code. With this technique, you can even provide error messages or code review feedback in specific code locations, and let Gemini improve the code for you. - Completing Code and Refactoring: It finishes partially written code and propagates related changes by fixing references throughout the file to keep everything consistent.
When invoked, Finish Changes automatically includes other open files as extra context to the model, ensuring it understands your project-specific styles and internal APIs. Gemini predicts edits to the file, and the changes are shown in the form of a diff where you can review, edit, apply, or discard the suggested changes.
You can invoke the finish changes by using command “Option+F” for Mac and “ALT+F” for Windows and Linux.
Outlines: A Living Design Document
The Outlines feature fundamentally improves code comprehension directly within the IDE. It generates concise, high-level English summaries interleaved with your source code.
Unlike standard paragraph-form chat explanations that are isolated in a side panel, Outlines are code summaries shown directly in the editor, interleaved within the code to align each summary statement with the code it explains.
- Full File Explanation: To reduce cognitive load, the IDE will automatically generate a detailed outline for the currently active file when the Outline sidebar panel is open.
- Interactive Navigation: The generated outlines are displayed in the editor and in a dedicated side panel. Each item in the outline panel is a clickable element. Clicking an outline item instantly scrolls the editor to the start of the corresponding code block.
- Customizable and Syncable: You can quickly toggle the visibility of the inline outline statements, switching between an annotated view and a code-only view to reduce visual clutter. If you modify the code, you can easily regenerate the outline to keep it synchronized with the latest changes.
You can invoke the sidepanel by using command “Option+O” for Mac and “ALT+O” for Windows and Linux.
Scaling Developer Velocity
Outlines drastically cuts down ramp-up time for new engineers by automatically summarizing code files, reducing the need to manually decipher and contextualize complicated code. Once you use Outlines to understand the code and pinpoint where new code edits should go, you can seamlessly transition to using Finish Changes. You simply start sketching out your logic or demonstrating a refactoring pattern, and let Gemini 3.0 handle the tedious implementation details.
