It’s been about six months since GitHub launched the Copilot technical preview back in June, and I’ve been using it daily since getting access in July. With the holiday break approaching and some quieter days ahead, it feels like the right time to share an honest assessment of what AI-assisted coding actually looks like in practice — beyond the flashy demos and Twitter threads.
The short version: it’s genuinely useful, occasionally brilliant, frequently wrong, and has changed how I think about writing code in ways I didn’t expect.
What It Actually Does Well#
Copilot excels at boilerplate. The kind of code you’ve written a hundred times — setting up an Express route handler, writing a database query, implementing a standard sorting function, building a React component with props. This is where Copilot saves me the most time, and it’s not glamorous but it’s real.
I’ve also been impressed by its ability to infer intent from comments and function names. Writing a comment like // Parse CSV file and return array of objects with headers as keys and having Copilot generate a reasonable implementation on the first try is genuinely delightful. It’s not always perfect, but it’s usually close enough that editing is faster than writing from scratch.
The tool is particularly strong with Python and JavaScript/TypeScript — no surprise given the training data composition. For these languages, I’d estimate it provides a useful suggestion about 40-50% of the time. For less common languages or specialized domains, that drops significantly.
Where Copilot truly shines is in test writing. Describe a function and its edge cases, and it’ll generate test scaffolding that covers most of what you’d write manually. I’ve found this to be the single biggest productivity gain — not because writing tests is hard, but because the mechanical aspect of setting up test cases is tedious enough that developers often skip edge cases.
Where It Falls Down#
Let me be equally honest about the problems. Copilot confidently generates code that looks right but is subtly wrong. I’ve caught it producing SQL queries with injection vulnerabilities, generating regex patterns that miss edge cases, and writing async code with race conditions. The code looks plausible, which makes it more dangerous than obviously broken code.
This is my biggest concern: Copilot lowers the barrier for producing code, but it doesn’t lower the barrier for reviewing code. A junior developer who accepts Copilot suggestions without deep understanding will ship bugs that a junior developer writing code manually might not — because the manual developer at least had to think through the logic step by step.
I’ve also noticed that Copilot sometimes generates code that works but violates project conventions. It doesn’t understand your team’s patterns, your error handling strategy, or your abstraction boundaries. It generates statistically likely code, which means it tends toward common patterns from its training data rather than project-specific patterns.
And then there’s the licensing question. Copilot was trained on public GitHub repositories, and there are legitimate concerns about whether it reproduces copyrighted code. I’ve seen it generate code blocks that look suspiciously like they were lifted from specific open source projects, sometimes with license-incompatible implications. The legal situation is murky, and I’d advise anyone using Copilot in a commercial context to be aware of this risk.
How It Changed My Workflow#
The most interesting effect has been psychological. I now think about coding differently — I write more descriptive comments before implementing, because I know Copilot will use them as context. I name functions more carefully. I structure my code in smaller, more self-contained units.
In other words, Copilot has made me write code that’s more readable for humans because I’m optimizing for an AI that benefits from clear intent signals. That’s an unexpected but welcome side effect.
I’ve also started using Copilot as a rubber duck. When I’m stuck on a problem, I’ll write a detailed comment describing what I need, see what Copilot suggests, and use that as a starting point for my thinking — even if I throw away the suggestion entirely. It’s faster than searching Stack Overflow for the specific pattern I need.
The Broader Implications#
Copilot is clearly a preview of where software development is heading. The underlying technology — OpenAI’s Codex model — is improving rapidly, and I’d expect the suggestion quality to get meaningfully better over the next year or two.
But I think the framing of “AI replacing developers” misses the point entirely. Copilot doesn’t replace developers — it replaces the mechanical aspects of coding. The hard parts of software engineering — understanding requirements, designing systems, making architectural decisions, debugging production issues, communicating with stakeholders — none of that is touched by Copilot.
If anything, tools like Copilot make those higher-level skills more important. When generating code becomes cheap, the value shifts to knowing what code to generate and why. Experienced developers who understand systems thinking, performance implications, and security considerations become more valuable, not less.
My Take#
After six months, I’m keeping Copilot in my editor. It saves me maybe 30-45 minutes per day on a typical coding day, mostly through boilerplate reduction and test scaffolding. That’s not transformative, but it’s meaningful.
My recommendation for other developers: try it with healthy skepticism. Treat every suggestion as a draft from a junior developer — potentially useful, definitely needs review. Don’t let it write security-sensitive code. Do use it for tests, boilerplate, and as a thinking tool.
We’re in the early days of AI-assisted development, and Copilot is a compelling first step. It’s not the revolution some claim, but it’s not a gimmick either. It’s a genuinely useful tool that happens to also be a glimpse of where our profession is heading.
Now if you’ll excuse me, I have some holiday coding projects to get to — with my AI pair programmer along for the ride.