Transcription
Hello. Today we have something interesting to review. Uh, fresh news from the Google Developers blog. Here, from August 13th, it's about the Gemini KL update. They say it now integrates deeply with Visual Studio C++. They claim it's a real game-changer. Let's see if that's true and what it gives us in practice.
Hello. Yes, this phrase "game-changer" here. It doesn't seem to be just for show. This isn't just a couple of new commands. The thing is, um, that Gemini C++, it starts to understand the context itself, what exactly is happening in the editor. This is a step, well, towards a truly smart assistant, which isn't somewhere on the side, but right there inside the process.
Okay. So, let's go with the first feature. Here's what they write: "Workspace and selection context. Sounds, well, intriguing. How does it work? So, C++ now sees which files I have open or if I've selected a piece of code.
Exactly. But not like it's peeking, but yes, it gets that info. And this is needed to give not general advice, you know, like, how to write a loop, but so that the recommendations are relevant specifically to this project, this file, or even this selected block. Ah, so imagine you're working on a complex function, you select a piece, and C++ then offers refactoring or finds an error. And all this based on the dependencies of your project.
Understood? So, less of this abstraction, yes, more specificity for my task. It sounds like it solves an old problem with assistants that often, well, suggest something completely irrelevant. This friction is reduced, where you first have to explain for a long time what you're even doing.
Absolutely, this cognitive load is reduced. The tool itself gathers the necessary context, at least the minimum. And this is especially valuable when working with large projects or when switching between tasks frequently. You don't need to brief C++ every time. It's kind of already in the loop. Well, thanks to the integration with the IDE. Essentially, it starts to work almost like, well, like a team member who sees your screen.
I see. It sounds really useful. What? What about the second big news? Ah, built-in file comparison right in the editor. Do I understand correctly that now, if Gemini C++ suggests something for the code, you can see it not just as text in the console, but as, well, as a full diff, like in Git.
Yes? And this is possibly even more important from a control perspective, when Gemini C++ suggests something to change, well, it doesn't matter, fixing an error, refactoring, or writing a new piece, it can now show it in a full-screen view right in VS Code. Your code on the left, what it suggests on the right, and all changes are highlighted. Clearly.
So, that's convenient, of course, for evaluation, but is that really something new? Many show diffs. But here's the key point. What distinguishes this integration? You can edit the suggested code right in this comparison window and do it before you click accept.
Ah, like that. So it's not just a yes or no choice, but an opportunity to take its suggestion as a basis, modify something for yourself, clarify details, and only then integrate it into your code. This gives the developer full control back and stops it from being such, well, a black box, it becomes an interactive assistant.
Now that's serious. So, you don't just blindly trust it, but you kind of collaborate with AI on the code. This probably alleviates some concerns that AI will write something wrong. The ability to tweak its version before accepting it sounds really good, powerful. But is it difficult to start using it? Surely there are some tricky settings.
But surprisingly, no. Getting started is quite simple. First, you need Gemini C++ version 0.12.0 or higher, that's clear. Second, you need to run it from the integrated VS Code terminal. Which is logical. And third, execute just one command: IDE install. It will install the necessary extension for VS Code. That's it.
Just one command? Yes? And then the integration can be turned on and off as needed. IDE enable and IDE disable. Everything is quite simple.
Mmm, it sounds really friendly. Yes? It seems Google is trying to make the entry as simple as possible. If you look more broadly, yes, we see a clear trend, and tools are integrating deeper into the development environment. Gemini, VS Code, C++, other tools are appearing there too. They all strive to become not just external utilities, but an integral part of the coding process itself. They gain access to context, understand project structure, and offer changes in a native way.
So, the assistant is no longer just some advisor from the side, but almost a partner who works with you in the same environment. And, well, understands what you're doing.
Exactly. And it stops being something external that you need to ask about separately. It becomes part of the environment, proactively helps, adapts to the task. And at the same time, as we see with the example of editable diffs, it leaves the final word and control to the developer. So, to summarize, tools are becoming smarter, integrating deeper into our editors, understanding context, and giving more control over what they offer. This is undoubtedly convenient. Potentially, this can significantly speed up development. But here's something to think about in conclusion. Such close integration of AI, which not only suggests code but also allows you to edit its suggestions on the fly. How might this change the very feeling of the code writing process? Doesn't the line blur here, where your work ends and AI's work begins? Doesn't coding turn into such a collaborative editing process? Where will this new line be drawn? An interesting question. M.