I got access to GitHub Copilot when it launched as a paid product in June. I've been using it daily for about a month now, and my feelings are genuinely mixed. It's simultaneously the most impressive and most frustrating developer tool I've ever used.

The "How Did It Know That" Moments

There are times when Copilot feels like it's reading my mind. I write a function name and a comment, hit enter, and it generates exactly the implementation I was about to write. Not approximately. Exactly. The right algorithm, the right variable names, the right edge case handling. In those moments, it feels like the future just arrived.

It's especially good at patterns. If I've written a few similar functions in a file and start a new one, Copilot picks up on the pattern and continues it perfectly. Writing Express route handlers, React components with a consistent structure, or database query functions that follow the same shape. It nails these because it can see the context in the current file.

Test writing is another strong area. I write the test function name like test_returns_empty_list_when_no_results and Copilot generates the setup, the function call, and the assertion. For straightforward unit tests, this easily cuts the writing time in half.

The "What Are You Doing" Moments

Then there are the other times. Copilot suggests code that looks plausible but is subtly wrong. An API call with the wrong endpoint. A sorting algorithm that doesn't handle the empty array case. A regex that matches too broadly. These suggestions are dangerous because they pass the glance test. If you're tired or distracted, you might tab-accept something that introduces a bug.

I've also noticed it sometimes generates code that uses deprecated APIs or patterns from older versions of libraries. It trained on a lot of GitHub code, and not all of that code was good or current. I've caught it suggesting jQuery patterns in a modern React project and old-style callback-based Node.js code when Promise-based alternatives exist.

The hallucination problem is real too. It'll generate confident-looking code that references functions or modules that don't exist. Especially when working with less popular libraries, Copilot will invent API methods that sound reasonable but aren't real.

How It Changed My Workflow

The biggest shift is that I now write more comments before code. Not for documentation purposes, but because comments give Copilot better context for its suggestions. Writing // fetch user by email, return null if not found before the function produces much better suggestions than just starting with async function getUserByEmail.

I've also noticed I'm faster at the boring parts of coding and no faster at the hard parts. Copilot can generate a CRUD endpoint in seconds, but it can't help me design the right data model or figure out a tricky concurrency issue. The thinking work is still entirely mine. Copilot just speeds up the typing work.

One unexpected benefit: it's actually helping me learn new languages. I've been picking up Rust on the side, and having Copilot suggest idiomatic patterns is like having a more experienced developer pair programming with me. Not always right, but often pointing me in a reasonable direction.

The Privacy Question

I need to mention this because it matters. Copilot sends your code to GitHub's servers to generate suggestions. If you're working on proprietary code, you should understand what that means for your company's IP. My employer's legal team reviewed the terms and approved it, but I know companies that have banned it entirely.

GitHub says they don't use your code to train the model further, and the business plan offers additional privacy protections. But the code still leaves your machine. That's a legitimate concern, and each organization needs to make their own call.

Is It Worth $10/Month?

For me, yes. Even with all the frustrations, I estimate it saves me 20-30 minutes a day. Over a month, that's meaningful. The key is treating it like a very fast, somewhat unreliable pair programmer. Review everything it suggests. Don't trust it on complex logic. Let it handle the boilerplate while you focus on the architecture and edge cases.

I think Copilot is a preview of something much bigger. This is version one. It's already useful despite its flaws. In two or three years, I suspect AI-assisted coding will be a standard part of every developer's toolkit. We're at the "early and rough" stage. But even now, the productivity gains are real enough that I'm keeping my subscription.

Just don't let it write your SQL queries without reviewing them. Trust me on that one.