The place where Copilot shines most for me is boilerplate like:

    up = foo.north()
    right =

    up = foo.north()
    right = foo.east()
    down = foo.south()
    left = foo.west()

For example, if I have a `Point` object with `x` and `y` fields, and I make a function called `lowest_point`, it knows I want to the point with the minimum `y` value. Because it knows the name `y` is most typically used for vertical direction, and the word `lowest` also implies vertical direction. This is kind of a linguistic/semantic knowledge that is not found in just the type system.

This is as credible as Ford doing a survey and finding out people got way more done with Ford trucks.

I found copilot to be nothing but a hinderance and additional cognitive load. Not only do you need to think about the code you want, you need to review the (usually wrong) code copilot produces and either reject it or edit it to make it right. This is a lot more mental overhead than just writing the code.

I spent most of the trial hating Copilot and the way takes over my Tab key in Jetbrains software. It got in the way a bit too much. Every time I tried to use emmet shortcuts, live template triggers or anything muscle memory related, it would bring something else, so I had to undo, press Esc a couple of times and then continue with whatever I actually wanted.

However, every now and then, there came a typed object or something mundane and Copilot exceled at it, so I decided that I want to find a way for it to coexist in a way that's as easy to use as pressing Tab to expand it. Lo and behold - I found an unused key below Tab (AKA caps lock), remapped it and now it doesn't get in the way and I can use Copilot's help only when I want.

I mostly enjoyed my Copilot trial but one thing that really annoyed me was that it would often make suggestions for strings/keys that would be decent guesses by the AI but would be obvious type errors in TypeScript. Then it seemed a bit tricky to fight through the incorrect suggestion and get the old TypeScript Intellisense which was of course correct and what I wanted. Other suggestions by Copilot were awesome but when there was an obvious job for TypeScript it would be nice if Copilot would step back. For example I would often type:

if (myTypedVar === "" <--

Back off Copilot, let TypeScript Intellisense give me the correct suggestions. Or at least run the Copilot suggestions through TS first and make sure it doesn't suggest type errors.

I'll tell you right now, having my GPL-licensed code stolen has a pretty negative impact on my happiness.

Any thread on copilot always seems to get a lot of comments about how it makes dumb mistakes. I guess I'm used to Intellisense etc making dumb suggestions all the time? I don't dwell on it for a second, either the computer makes a good suggestion that was what I was about to do and I accept the suggestion, or it doesn't and I don't accept it. I'm certainly not going to sit there and stew over how dumb it was to suggest such a thing, it's a damn computer!

Cognitive load is massively decreased, I don't have to push much on the working memory stack to do small utility functions, they just write themselves now (especially if I write the type signature first). I can spend a lot more of my time at the middle level of abstraction, and keep moving.

This seems like something obvious, but I didn't really appreciate it until I was actually using copilot day to day.

When you're using it on a code base that it's familiar with, it'll often suggestion quality of life suggestions that you may not know about.

For example, using unity, did you know

    Mathf.RoundToInt 

I didn't, until I was using a normal way of doing it (eg. `(int) Math.Round(v);` and copilot popped this suggestion up.

I had similar experiences using opencv in python.

Maybe the suggestions aren't always perfect, but what it does do, is show you how other people have written code using the same engine/plugin/library you're using; and when you're learning a new API, that's extremely valuable.

The alternative (finding github projects using library X, browsing through the code) lets you do the same thing too, but its much much slower to pickup the same 'tips' about an API that way.

Specifically with regard to "give people a new task they haven't done before in language X with/without copilot", this kind of 'tip' for using an unfamiliar API seems high plausible for getting developers up to speed.

I wish it had support for doing this in a way that was 'favour suggestions like existing code base' to help on-board new developers.

That would be really really useful.

I ended up disabling it in the beta. It ended up getting in the way more often than not.

To me it's an added level of attention required, having to be extra careful (as I'd be when reviewing a junior's code) with any code suggestion copilot suggests... even if it's wrong 10% of the time, I need to be on the look for lines that would just cause a bug down the line. Ended up disabling it.

I don't understand all the negative comments, my experience with Copilot is just insane, it really is autocomplete on steroids. It's hard to fathom that some people have a bad experience with it.

I'm doubtful that the results from the experimental process can be used to draw such generalizing conclusions about the utility of Copilot. The task (implementing a HTTP web server in JS) is already something that would be over-represented in public codebases, this is like asking participants to implement two sum or a sudoku solver, of course the language model would have essentially memorized these types of problems.

"and timed how long it took them to write an HTTP server in JavaScript"

OK ... interesting choice. This could mean almost anything. I can "write a web server" in a python 1-liner in about 2 seconds (ctrl-r SimpleHttpServer, enter).

There is a real need for offline co-pilot alternative.

Privacy concerns due to copilot makes it unusable for companies with closed source code.

I’m hoping that eventually there will be a stable diffusion level solution in this field.

Maybe I’m weird, but I kindof like programming. Even my own “boiler plate”. And good coding practices combined with well factored code design and planning (even in the micro-moment to moment sense of design and planning) usually avoids most “boiler plate”. (“Boiler plate” is usually a misnomer in modern well-designed languages. If the pl or ps makes you write something out, it usually is bcs you have the opportunity/obligation to think about it and usually to tweak it. If it was actually always the same, it would have good defaults and wouldn’t be there at all.)

I use Copilot constantly and it's one of my favorite developer tools ever.

I wasn't that bothered about it until I used it. The biggest thing for me is when working with Terraform and some really badly documented parts of it and really not being able to work out the syntax required, the suggestions really helped expedite what would otherwise be a lot of iteration.

What would be great would be for an enterprise pricing capability, we would love to purchase this on behalf of our employees via a single interface.

Has anyone considered creating an extension like co-pilot that's trained on your own reddit/hn/twitter comments? Basically like an autocomplete for your own self.

I've not used it, and probably never will, but why do people want non deterministic snippets again?

Seems like popularizing snippets wouldve gone further but then you miss out on the buzzwords.

I really love Copilot. I had a trial, let it expire because I thought I wouldn't really need it, and then ended up paying for it. It's apparently got even better. For me, at least, it gets most things very right and takes a lot of mundanity out of day to day development!

I read the article and I have some skepticism. I think my skepticism is well-founded but it may well be the case that a machine will one day do my job. I don't believe that time is at hand, though.

First off, I don't see a link to the "HTTP server in JavaScript" task. It's really hard for me to place much faith in their conclusions when it's not even clear what the problem definition was.

Second, I believe that a lot of more senior developers and development managers who take secure development practices somewhat seriously will not be able or willing to use Copilot in any sort of proprietary setting. Here is a quote from the Copilot FAQ:

> [...] The GitHub Copilot extension sends your comments and code to the GitHub Copilot service, and it relies on context, as described in Privacy below - i.e., file content both in the file you are editing, as well as neighboring or related files within a project. It may also collect the URLs of repositories or file paths to identify relevant context. The comments and code along with context are then used by OpenAI Codex to synthesize and suggest individual lines and whole functions.

- from https://github.com/features/copilot/#faq - see "How does GitHub Copilot work?"

I believe this makes it simply a nonstarter in a lot of environments. I am wondering if there are a number of places that have restrictions on sharing their code with a third-party but don't know or don't care and so end up using Copilot anyway. I believe that short-sighted thinking like this is more prevalent in shops that have low-quality code, and I believe that the higher-quality the code, the less likely someone is to use Copilot, simply for the "I can't share my code, even if I use the most restrictive no-telemetry settings" reason. Give me a self-hosted Copilot, and I may try it out in anger.

Finally, I based some of my thinking on a recent Reddit /r/programming discussion of Copilot: https://old.reddit.com/r/programming/comments/wsnend/since_g...

After reading those posts, and internalizing them with my own view of coding, I believe Copilot is not ready for my personal use. Again: licensing considerations aside (if you actually can feel comfortable putting them aside, see NoraCodes comment in this HN thread e.g.), it is simply a non-starter for anything proprietary in nature. I am also of the mind that any code that is of necessity very tedious to write is in dire need of real attention, most likely in the form of tests and quite possibly refactoring to reduce the boilerplate if at all possible. I believe in the value of linters and automated code analysis tools and in continuous integration that runs after every commit. Give me a self-hosted Copilot, and we'll have a real chance to see how it works out - until then it's not going to be a boon to programmers.

ITT:

A bunch of insecure clowns that somehow manage to feel personally threatened by a productivity tool. It's hilarious. Get over yourselves.

Copilot is just an intelligent, context-aware search engine that is plugged directly into your code editing workflow. It's nothing more. It's the sci-fi version of having a hardcoded `site:stackoverflow.com` google search box right next to your editor.

It's easily the nicest thing I've installed for productivity in a while, and it regularly amazes me what it can pick up from context. I can switch between code written in two different languages that is related, and copilot will often pick up enough context to give me correct suggestions in one language based on the code I just wrote in the other.

How's Copilot with really good statically typed languages like Haskell? I haven't tried it out because most comments say it doens't even work well with typescript yet...

It should be free since it was trained using free software.

Anecdata: Copilot has been net-negative for me when writing Python, but the Rust completions are fantastic.

I liked using it. Though, most of the time, it was limited, in the sense that it could only offer completions using the code before the cursor as the context.

I found it most helpful in setting up boilerplate in when writing tests. It could offer testing some edge cases before I could think of them.

undefined

Wish the auth was better