Copilot Integration in development

Over the weekend I decided to use the remaining GitHub Copilot tokens I still had left, since the end of the month is coming and the reset is close anyway. I spent the time testing the newer models both in Visual Studio 2022 and 2026, and also in VS Code, mainly on real projects rather than small test examples.

Visual Studio still has some noticeable drawbacks in how the module is implemented, but nothing you cannot get used to. The usage is less intuitive, the commands are slightly different, for example instead of #codebase it uses #solution, and similar things. It works, but it does not feel as natural as it could.

That said, it already works very effectively once a project is open. The usual rule still applies, the smaller and better documented the project is, the better the results are. The problem is that the context of a Visual Studio solution is simply much more complex, so it requires more control and supervision from the user. It is not something that just works completely on its own.

What surprised me the most, though, is how big the difference between the new models really is. Sonnet and Opus are on a completely different level compared to what I used to get from GPT-4 and GPT-5, especially when it comes to programming and working with real code.

In VS Code, the new models feel almost suspiciously intuitive. They behave as if they instantly understand what you have opened and what you want to do with it. Ironically, they require less supervision there than in Visual Studio. However, Visual Studio projects are still more complex for them, and I would not recommend mixing VS Code into a large Visual Studio project. It is simply not built for that, and in those situations the integrated module inside Visual Studio may actually work better.

On Friday I spent some time going through an anonymous project with Opus and let it analyze part of the system. It produced a really solid breakdown of how the searched implementation, and the explanation actually made sense. It even generated ASCII diagrams, which I did not expect at all, but it turned out to be surprisingly useful.

During the weekend I also tried opening an old PHP web project of mine (not this website, lol). The project is really old and written in a very inefficient way, in some places it is closer to spaghetti than proper code. Despite that, the model had no problem navigating through it. It not only created a structure diagram of the website, but it was also able to modify code that is far from ideal. When I asked it about refactoring the project, it created a full plan and immediately started suggesting the first changes.

I tried some of that directly with Opus, but later I switched to Sonnet because Opus is very expensive in terms of tokens. What surprised me again was that Sonnet continued as if nothing had changed, as if I had not switched models at all.

I also tested a few smaller projects that I worked on years ago at school, and those worked without any problems. But those were much smaller, so the complexity of larger projects was not really a factor there.

Sometime during the night from Saturday to Sunday I ran out of tokens, and I noticed something different compared to earlier. It did not allow me to continue beyond 100 percent anymore. That probably means the service was updated, or that this became a configurable limitation. From what I could find online, there was a major update on the GitHub side about a month ago, including changes to free and student plans, so it might be related.

From that point on I had no choice but to compare it with GPT-4 again, and honestly the difference was stunning. It suddenly felt like the model understood maybe 30 percent of the code at best. Errors started appearing, it kept deleting working code, then apologizing and writing it again, and constantly asking if it really should do what I told it to do. In large files it even removed hundreds of lines of working code just to add a single extra method, and sometimes that method was wrong anyway.

For real development, that is incredibly frustrating. Even if you have no other option, working with it feels more like a fight than actual help.

On the other hand, Opus and Sonnet work extremely well right now. One of the biggest improvements is the larger context memory, which makes a huge difference in real projects. Older versions of Sonnet are still capable, but if they cost the same amount of tokens as the newer ones, there is really no reason to go back.

If I had to summarize the whole weekend, Opus is perfect for deep analysis and more complex operations. Sonnet is ideal for smaller tasks and everyday development work. And GPT, at least for now, is not something I would use as a development copilot. The newer models definitely require less micromanagement than before, but you still need to stay in control and verify what they do.

According to the documentation, Visual Studio works with the model in a completely different way than VS Code and relies much more on the full solution context. That probably explains why the experience feels so different between the two, even though the explanation is very general.

In the end, though, it is still just a tool. It depends entirely on how well you learn to use it. You can also do a lot of damage with a hammer if you use it the wrong way. AI is just another tool, and it works only as well as the person using it.

And one last thing. I use AI almost exclusively in English, and I am pretty sure that has a noticeable impact on the results.

I still recommend exercising a healthy amount of skepticism when using AI for anything. Check the results, check for sources (and if they exist) and don't listen to GPT's bootlicking for egoists.