Experienced Devs

The autocomplete is fucking fantastic for writing unit tests, especially when there’s a bunch of tedious boilerplate that you frequently need SOME OF. I’m also really impressed by its ability to generate real code from comments or pseudocode.

Generally, though, I find it pretty awful for writing non-test code. It too often hallucinates an amazing API and I kick myself for not knowing it existed. Then I realize it’s because the API doesn’t actually exist, and the dumb fucker is clearly borrowing from a library from a completely different stack.

I often felt that current ML speeds up newbie devs by effectively teaching them the language and libraries — but slows down experts that already know the stack well from memory. I started coding in a new language and system, and ML can be a bit faster to teach me things and provide simple snippets than stack overflow

But over time I've learned that there are very specific things that ML can do really well, and I can save time when I apply those techniques. For example, it's excellent at converting from one language or style to another, ex migrating configs from json to yaml. It's also pretty good at writing configs or generating template code based on them. It's good at picking an emoji from a list. It can write small functions or provide a template html layout. So I humbled myself and started integrating it into my workflow where it actually works

i find it useful for things outside my areas of expertise. been doing a lot of devops lately and even though it usually fails in the specifics it can generate the broad structure of a yaml pipeline and enough pointers that i can find the right thing in the docs.

Like most have already said, the auto complete is top tier while the chat is hallucination-riddled and not always useful. I find that if I'm asking Chat a question, my problem is already so complex that the AI struggles to answer it without the entire context of the application. It will give me unrelated answers, fake answers, or extremely basic ones that miss the broader context. It's really a coin flip on whether it will help.

I have also had the autocorrect make a mistake once and that was extremely annoying. It was the type of mistake I would have made but took way longer to figure out because I trusted it too much

I'm actively campaigning at work to have github be declared no longer safe for data we need to keep sovereign. This includes all our ansible junk. As the corporation is based in America and is comically ignorant of the privacy rules this particular rest-of-world sub-organization needs to work under to keep data from getting to America - arm's length no-shared-data kind of op and everything - it's continually baffling we used github.com before. With this it seems a sad joke for security, privacy, and compliance.

Nah, it's all hyped up bullshit that has to be babysat and manipulated to a degree that you may as well just write your damn code.

But beyond that, I'd argue that it's actually damaging for engineering organizations, because it means the org is incurring the maintenance cost of code not written by its engineers and that has no real thought put behind it. Maybe you can eventually coax it to produce code that's not completely broken shit, but it's code that your org doesn't actually "own" from a maintenance and knowledge-base perspective. The social aspect of code maintenance with this shit is always massively overlooked.

The autocomplete is nice but I don't find it a game-changer. The comment about writing tests is on point though, but that's the only place I found out useful.

Copilot and that whole model is a bunch of shit

Get Claude.ai, do the thing of pasting the code you want it to modify into the chat window, and it’ll spit back out some modified sections of code you can put back into the file. It is more time consuming, but it actually works.

For intense operations you can make a project, upload the main headers and documentation, and it’ll absorb them into its sphere of awareness and start being able to take account of them when it does the above in chats within that project.

It is not perfect (as no LLM assist is) but it saves a lot of time and is not beset with the growing incompetence and failure with which OpenAI seems to be afflicted more and more with every passing month

I don't use chat, it's usually useless. Autocomplete is good enough that I can worry about concepts and Copilot will tab me the SQL blocks, loops and functions; I feel like it's a better flow and I'm faster over all.

For stuff like Angular it knows 95% of what you're trying to do since the possibilities are limited.

Somewhat useful with (neo)vim, where it's (however tiny af) context window spans every open buffer

My company pays it for me. My use cases are split between new development, refactoring and debugging.

For new code, given that our code base is proprietary but very extensive, it provides nice code snippets that would be a pain to write by hand (it's mostly C code) such as test code

I can focus on the concepts and have the autocomplete do the rest for me. I swap keypresses for reviewing code, which is not bad.

For refactoring, I seldom use it because I haven't found an use case for it. Most of the changes involve moving code around, adding glue or deleting dead code.

For debugging, I sometimes use the chat to get documentation on public APIs from Microsoft or other places. I use this documentation to check for invariants and to reduce the scope of what I'm trying to find out.

Nop, it's slow and dumb imo. It has only ever been able to write stuff I could type quicker and with less bugs anyways.

chatgpt has been helpful two or three times. And it makes a decent ish code monkey when you give it a template. But in any editor with multiline editing it's redundant

I use chat the most. It's pretty good once you understand the importance of building context, set up personas, and feed it workable prompts. The biggest mistake I see people do is presume that you can expect it to output gold when inputting garbage.

Once you build up an understanding of what personas work for your personal tastes and what context you need to have, it can output impressive results. The most success I've been having is with somewhat complex refactorizations. Stuff like "refactor X so that Y and Y" can save you a lot of time.

The most disappointing experience has been with writing unit tests. copilot has this infuriating tendency to remove old tests when you're prompting it to add new ones. You need to explicitly request it to append tests to file X without overwriting existing tests for it not to mess up, and even then results are sketchy. For unit tests it's also important to setup good contexts otherwise whatever time you save by prompting copilot to write them will be wasted refactoring code to use specific frameworks and follow specific styles.

I primarily use it for C++ in Unreal Engine and use it almost exclusively to write log statements. The way to log something is done via a macro like so:

UE_LOG(LogCategory, Warning, TEXT("My variable: %s"), *SomeStringVar)

Writing that boilerplate soup gets tiresome after a while, so having Copilot autocomplete the log statement for me based on other statements in the same file and the context of the function is godsend.

It does of course happen that the text contents are wrong, but then I have that skeleton to work with. Just erase the text and type the correct contents I want. Saves so much time.