Introducing Finish Changes and Outlines, now available in Gemini Code Assist extensions on IntelliJ and VS Code

Google has introduced Finish Changes and Outlines for Gemini Code Assist in IntelliJ and VS Code to reduce developer friction and eliminate the need for long, manual prompting. Finish Changes acts as an AI pair programmer that completes code, implements pseudocode, and applies refactoring patterns by observing your current edits and context. Meanwhile, Outlines improves code comprehension by generating interactive, high-level English summaries interleaved directly within the source code to help engineers navigate and understand complex files.

Unleash Your Development Superpowers: Refining the Core Coding Experience

The Gemini Code Assist team has introduced a suite of updates focused on streamlining the core coding workflow through high-velocity tools like Agent Mode with Auto Approve and Inline Diff Views. These enhancements, along with new features for precise context management and custom commands, aim to transform the AI from a general assistant into a highly tailored, seamless collaborator that adapts to your specific development style.

Better screen scaling for Google Calendar on large monitors

Google Calendar on the web now offers improved scaling on large, high-resolution monitors. This update provides a clearer overview of your day by reducing unnecessary whitespace and better utilizing your available screen space.

Previously, users with large or high-resolution monitors may have felt that it was difficult to get an overview of the day's most relevant events.

This update means:

  • Better visibility: Calendar events will better fill the available space, giving more room to short meetings.
  • Focused views: The grid will prioritize showing a relevant 12–15 hour range (such as 7:00 AM to 7:00 PM) based on your viewport height.
  • Consistent experience: These improvements apply to both the main Calendar application and the side panel companion view in other Workspace apps (e.g. Gmail).

Getting started

  • Admins: There is no admin control for this feature.
  • End users: This feature will be ON by default. Users can manually adjust their view preference under Settings > Appearance > Information density. Visit the Help Center to learn more.

Rollout pace

  • Rapid Release domains: Extended rollout (potentially longer than 15 days for feature visibility) starting on March 10, 2026
  • Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) starting on April 10, 2026

Availability

  • Available to all Google Workspace customers, Workspace Individual subscribers, and users with personal Google accounts

Resources

The Way of TDD


This article was adapted from a Google Tech on the Toilet (TotT) episode. You can download a printer-friendly version of this TotT episode and post it in your office.

By Bartosz Papis

Test-Driven Development (TDD) is the practice of working in a structured cycle where writing tests comes before writing production code. The process involves three steps, sometimes called the red-green-refactor cycle:

  1. Write a failing test 
  2. Make the test pass by writing just enough production code 
  3. Refactor the production code to meet your quality standards
The three steps in TDD

Research shows TDD has several benefits: it improves test coverage, reduces the number of bugs, increases confidence, and facilitates code reuse. This practice also helps reduce distractions and keep you in the flow. TDD also has its limitations and is not a silver bullet! See the Wikipedia article about TDD for a detailed explanation and references.

Here is a short practical example. Assume you need to modify the following voting algorithm to support the option for voters to abstain:

def outcome(ballots):

  if ballots.count(Vote.FOR) > len(ballots) / 2:

    return "Approved"

  return "Rejected"

1. We start by writing a failing test - as expected, the test doesn't even compile:

def test_abstain_doesnt_count(self):

  self.assertEqual(outcome([Vote.FOR, Vote.FOR, Vote.AGAINST, Vote.ABSTAIN]), "Approved")

2. We fix the compilation error by including the missing enum option:

class Vote(Enum):

  FOR = 1

  AGAINST = 2

  ABSTAIN = 3

Now that the test compiles, we fix the production code to get all tests passing:

def outcome(ballots):

  if ballots.count(Vote.FOR) > (len(ballots) - ballots.count(Vote.ABSTAIN)) / 2:

    return "Approved"

  return "Rejected"

3. We now refactor the code to improve clarity, and complete an iteration of the TDD cycle:

def outcome(ballots):

  counts = collections.Counter(ballots)

  return "Approved" if counts[Vote.FOR] > counts[Vote.AGAINST] else "Rejected"


Learn more about TDD in the book Test Driven Development: By Example, by Kent Beck.