I was writing a Go function to parse structured log lines into a map last Tuesday. Boring stuff. The kind of code I’ve written a hundred times. I typed func parseLogLine(line string) and Copilot filled in the entire function body. Correct return type. Correct error handling with strings.SplitN. Even used strings.TrimSpace on the values.
I stared at it for a second, accepted it, ran the tests. They passed.
That’s the Copilot experience in a nutshell. Sometimes it’s genuinely impressive. Sometimes it’s confidently wrong. The trick is knowing which is which.
What it actually is
Copilot is a VS Code extension powered by OpenAI Codex. It’s not autocomplete in the traditional sense – it doesn’t just finish your variable names. It tries to generate whole functions, blocks, or patterns based on your comments, function signatures, and the surrounding code in the file.
I got into the technical preview in late June 2021. I’ve been using it exclusively for Go code, so that’s the lens here.
Where it’s genuinely good
For boilerplate, Copilot is fantastic. Go has a lot of boilerplate. HTTP handlers, struct marshaling, error wrapping, test setup – the repetitive stuff that eats time but doesn’t require deep thinking.
I wrote a comment: // handler that accepts JSON body, validates required fields, returns 201. Copilot generated a handler with json.NewDecoder, field validation, and proper status codes. It wasn’t perfect – the error responses needed tweaking – but it saved me a solid five minutes of typing.
Test scaffolding is another win. Table-driven tests in Go follow a predictable structure. Copilot picks up on the pattern fast. After writing two test cases, it started generating plausible cases for the remaining branches. I still had to review them, but the structure was right.
Small utility functions with obvious names are where it shines the most. func containsString(slice []string, s string) bool – Copilot nails this every time. Which makes sense. There are probably thousands of identical implementations on GitHub.
Where it falls apart
Domain logic. Anything specific to your business, your data model, your weird edge cases. Copilot has no idea what your system does. It only knows what’s in the current file and whatever patterns it learned from public repos.
I tried writing a function to calculate pricing tiers based on our custom rules. Copilot confidently generated a completely wrong implementation. It looked reasonable. The types were right. The structure was clean. The logic was entirely made up. This is the dangerous part – the suggestions look competent even when they’re wrong.
Go error handling is another weak spot. Copilot sometimes swallows errors or returns nil where it should return an error. For a language where explicit error handling is the whole point, that’s a real problem. I caught it in review, but a junior developer might not.
And I wouldn’t let it anywhere near auth code, crypto, or anything security-sensitive. The cost of a subtle mistake there is too high to save a few minutes of typing.
The licensing question
This one bothers me. Copilot was trained on public GitHub repositories. Some of those repos have licenses that require attribution. When Copilot suggests code that’s functionally identical to a specific open-source implementation, what’s the obligation?
GitHub’s position is that this is fair use. The open source community isn’t uniformly convinced. I’ve seen Copilot suggest code that’s essentially a direct copy of a popular library function. That might be legally fine. It might not be. In June 2021, nobody has a definitive answer.
For my own use, I treat every suggestion as code I need to understand and own. If I can’t explain what it does and why, I don’t accept it.
How I’m actually using it
I keep Copilot on for everything except security-sensitive code. My workflow:
- Write a clear function signature or comment
- Look at what Copilot suggests
- Accept it if it’s right, ignore it if it’s not
- Run tests regardless
The key insight is that Copilot is fast autocomplete, not a pair programmer. It doesn’t understand intent. It doesn’t know your system. It pattern-matches against a massive corpus. That’s useful. It’s also limited.
I’ve been more deliberate about naming since I started using it. Good function names and clear comments produce better suggestions. That’s actually a nice side effect – Copilot rewards code clarity.
My honest take
Copilot is the most interesting developer tool I’ve tried in years. It’s not going to replace anyone. It’s not going to write your system for you. But for the 30-40% of code that’s repetitive structure, it’s a real time saver.
The technical preview is rough around the edges. The latency is noticeable sometimes. The suggestions are inconsistent. The licensing questions are unresolved.
But I’m going to keep using it. For a first version, this is surprisingly useful. I’m curious where it goes from here.