If you had asked me a year whether I thought that AI generated code was decent enough for production, I would have probably said no. The hallucinations were too frequent and (usually) the code was not very well optimized. But I knew that it was only a matter of time before the models caught up.

Well how things have changed in the span of a year. Just recently I accidentally 're-enabled' my VS Code GitHub Copilot extension and didn't think anything of it. I clicked on the icon, it asked me to login to my GitHub account, and I said why not.

And for the next couple of hours, I found myself staring at code completions that were better..and better...and better. To the point where on a long coding session day for work, I found myself hitting 'tab' more than writing actual code.

And after burning through my 2000 free code completions in the span of a few hours, I decided to take out the old credit card and to make it official. Because at this point, I think it's 100% worth the monthly cost. In this guide, I'll break down exactly why, in case you've been contemplating giving more chatbots your money.

GitHub Copilot Code Completions: How Well Do They Work?

GitHub Copilot has a few components that make it tick. But for me personally, code completions are at the top of the list. If this isn't good, then I'm not interested.

Code completions are essentially inline suggestions that appear as you type into the editor. This isn't anything new, and we do have code suggestions in most IDE's that aren't AI-based.

However, these simpler suggestion models of the past could only really finish off a keyword at most. They were great for spelling, but not for much else.

What I found was that the more that I used this feature, the better it got at recognizing my coding patterns. It was declaring variables in the same style, it was creating functions with the same signatures, and it was even using my custom utility libraries where appropriate.

It wasn't always perfect, but the amount of changes that I personally had to make to the generated code were less and less. And that's important to note, because I'm not at all looking for '100% perfect, clean, optimized code'. In my 20+ years as a programmer, I've never really done that. I just need it to work within reasonable bounds.

And right now, as of this writing, the code is very decent. All of this is of course possible because of the models that are being used. My configuration right now uses Claude Sonnet 3.5, which is my personal go to for coding as it does seem to product less hallucinations (usually).

But by far the most useful way to use Code Completions was by writing a comment with exactly what I wanted and then having it magically appear seconds later.

Fyi, don't use a Caesar Cipher to encrypt anything. That was just an example. But a clear example that it doesn't really matter what you're coding in the moment. Copilot can more or less pick up on what you're trying to accomplish.

And anything that saves me time is going to get my attention.

Copilot Edits: Can It Really Modify Your Code?

Second on my list of 'core' Copilot features is Copilot Edits. This is relatively new and I personally have only spent a week using it as of this writing. But essentially, here's how it works:

• You add your files to a session
• You type your prompt on what you want to do with those files
• Copilot will modify your codebase
• You accept/decline the changes

When it works, this feature is a game changer. Being able to create a new file and simply type 'build a pricing page and store the plans/tiers in an array', reduces so much of that cognitive load that developers have to go through when doing repetitive tasks, like setting up basic site pages.

I say 'when it works', mainly because the quality of the code generated will really depend on the quality of your own code. If your file is a total mess with unused functions, poorly named variables and clear and obvious errors, then you can't really expect too much.

On some of my more poorly written files, I definitely noticed that either Copilot made few to no changes, or that the changes it made were partially complete. Fair enough.

But when it was tasked with editing a relatively well structured component (in React let's say), it definitely was able to keep up with the logic. One example that stands out was when I needed to build a 'filter and sort' bar on top of a data table. Every developer knows just how tedious that is, mainly because its the same process every single time.

So I let Copilot take a stab at it. And it made a substantial amount of changes that I more or less 'reviewed' before hitting 'Accept'. And to my surprise, it worked great. Something that would take me 15-20-30 minutes to type out and to test, was done in a couple of seconds.

If anything, it at least saves a couple of brain cells when having to set up boilerplate code.

Copilot Chat

The Chat feature in Copilot is great for breaking things down. However, for me personally, I don't use it too often. And this is mainly because I only tend to work on code that I myself have written.

But I can definitely see the value in a team setting, because when I worked corporate back in the day, I would mainly spend my days looking at someone else's code. Having the ability to highlight a function and to have a full break down and explanation without having to leave your IDE is huge.

You can also have the Chat review your code and add comments as needed. Again, great to have for a corporate setting with many devs and managers, but not so useful when running your own codebase.

All great features, that honestly, 22 year old me would have never believed possible.

✅ Pros: Why GitHub Copilot is Worth It

• Massive Time Savings

• Automates repetitive coding tasks, reducing hours of work to minutes. Inline code completions are fast and increasingly accurate over time. Adapts to Your Coding Style

• Learns and mimics your variable names, function signatures, and patterns. Even recognizes custom utility functions and suggests them where relevant. Great for Boilerplate & Setup

• Generates pricing pages, filter/sort bars, and other common components with minimal effort. Reduces the cognitive load of writing repetitive structures. Copilot Edits Can Modify Entire Codebases

• Lets you modify multiple files at once by providing a single command. Works well on structured, clean code (though results vary on messy files). Built Directly into VS Code

• No need to switch between a separate chatbot and your code editor. Tight IDE integration allows for inline chat, code explanations, and debugging. Useful for Reviewing & Explaining Code (Especially in Teams)

• Copilot Chat can break down complex functions, add comments, or review existing code. Great for corporate environments where devs spend time analyzing others’ work. Better Model Performance Over Time

• A year ago, Copilot hallucinated too much—now, the code is far more reliable. Claude Sonnet 3.5 integration (if used) seems to improve response quality.

❌ Cons: Where GitHub Copilot Falls Short

• Still Not Perfect (Requires Review)

• Not 100% accurate—requires human oversight and debugging. Sometimes generates partially complete or inefficient code. Performance Varies Based on Code Quality

• Works best on well-structured codebases but struggles with messy, unclear files. Poorly written functions = poor AI suggestions. Copilot Chat is Less Useful for Solo Devs

• If you write your own code, you probably don’t need Copilot to explain it to you. More beneficial for corporate teams reviewing unfamiliar codebases. Costs Money After Free Limit

• The 2,000 free completions go fast—especially on long coding sessions. Requires a monthly subscription after the free limit is reached. Not a True Replacement for Human Creativity

• Can’t think beyond patterns—it’s not great for unique problem-solving. Best for boilerplate, utility functions, and simple implementations rather than deep logic.

Is GitHub Copilot Worth the Price?

After burning through my 2000 free completions in a single afternoon, I did not immediately jump to take out my credit card. I spent around 2 days going back to my old coding routine.

At this point though, it was clear just how much time I was spending in the past having to write out every single line of code by hand. It was a lot. Not to mention the amount of time spent on fixing small bugs like typos and such.

And something that would normally take me 4-5 hours to finish, could realistically be done in 1-hour I realized.

A year ago, I probably would have a different opinion on this whole thing. Mainly because of the quality concerns. But that problem seems to have been fixed (or at least vastly improved), and instead of continuing to wait for the 'perfect code generator' that's in the top 99th percentile of software developers in the world, I think what GitHub Copilot is offering right now is good enough to give you back hours of your life every single month.