I'm not sure I agree with the thesis of this post. It seems to me asking if something is right vs when compiling to test, and iterated to work, does seem like it helps programmers.
>> I have tried to understand how I could use ChatGPT for programming and, unlike Welsh, found almost nothing.
Errr..... how can this guy say all this in the face of thousands of developers talking about how AI helps them, about AI copilots being built that demonstrably assist programming.
My personal experience being that AI has turned programming into a completely different process.
What does this say about the author, that they can argue a point so obviously wrong?
I don't know that it's obviously wrong. I know a handful of devs that have been using LLMs as part of their development process. About half of them have seen some increased productivity from doing so (none of them produce better code).
So it appears to me that neither the ones claiming that AI helps them, nor those saying it doesn't, are wrong. Not everyone finds AI to be helpful when coding.
Errr... I think there are a thousand developers talking about how AI doesn't help them, so I don't think that's a good argument.
My personal experience is:
- Writing some boilerplate/copy-paste testing code might turn out fine, but I still need to check it and that takes more mental effort than to just copy-paste-adapt with well-known keyboard shortcuts.
- Writing business-relevant production code that is readable, maintainable and concise: Forget AI (at least for now).
On good days I try to use and adapt to LLM-generated code, but at the end of the day, when I have to get things done I turn them off: It's easier to reflect and build a complex system without someone constantly "trying" to bullshit you... After all the LLM does not (yet?) know about all the details, the why and all other things that produce something readable, correct and concise.
My grandmother -- a talented chef -- refused to eat fast food or frozen meals. Perhaps she overvalued her capabilities or didn't try hard enough.
I don't use "AI" to help me write code, it doesn't help me enough to offset the constant context switching, and then having to double-check what it spits out. For the same reason, I don't have a junior-level human assistant to pair with because that would slow me down.
Thanks for the heads-up, so those of us not getting enough value out of "AI" (about half according to the other comments) know not to apply. I have worked for plenty of managers and executives who can't write a memo or a spec as well as ChatGPT, I suspect those jobs will go to "AI" before my prospects dry up.
Sometimes people mistake convenience for something being good for them. I can conveniently do so many things in life without having to figure them out by myself, and they may indeed save me time and effort. Doesn’t mean it’s good for me or improves my own value proposition.
> What use do I have for a sloppy assistant? I can be sloppy just by myself, thanks, and an assistant who is even more sloppy than I is not welcome. The basic quality that I would expect from a supposedly intelligent assistant—any other is insignificant in comparison —is to be right.
> It is also the only quality that the ChatGPT class of automated assistants cannot promise.
Show me one assistant who can promise they are right 100% of the time and I will show you one liar.
Copilot & Copilot Chat cut down my coding time on a brand-new ML optimizer that was released in a paper last week from what would have been 20+ hours into a 4-hour session and I got fancy testing code as a free bonus. If I had coded it by myself and taken the full amount of time it would have taken to figure out which parameter was being sent on which layer for which gradient was currently being processed, I wouldn't have had the energy to write any tests.
I don't understand what people's expectations are of AI that they're being disappointed. You figure out the limitations quickly if you use it on a regular basis, and you just adapt those shortcomings into your mental calculus. I still code plenty by myself in a good old vim session because I don't think copilot would actually be very useful in reducing the amount of time it would take me to code something up, but I don't count that as a "failure" of AI, I view it as knowing when to use a tool and when not to.
I find this notion deeply unconvincing. An assistant being consistently right matters when you give them simple gruntwork that you yourself can do fairly fast, and where it so is not helpful if you need to spend much time checking it. You quickly learn which types of tasks like that ChatGPT can do precisely enough to be worth it.
But for many other tasks, getting an outline - even a broken one - can often unblock things. I've noodled with fixing a bug in a compiler for a while, and asking ChatGPT gave me a solution that didn't work, but that was close enough to give me an outline of an approach that unblocked my own thinking.
It's more productive of you don't look at ChatGPT as a piece of software you expect flawless output from, but more like a slightly dense and annoying junior dev that you need to learn to work around: When you know its limits and use it accordingly, it can still save you time. If you expect it to do too complex tasks on its own, on the other hand, you end up with a time consuming mess.
> But for many other tasks, getting an outline - even a broken one - can often unblock things. I've noodled with fixing a bug in a compiler for a while, and asking ChatGPT gave me a solution that didn't work, but that was close enough to give me an outline of an approach that unblocked my own thinking.
I suspect Meyer would agree with you:
>> Help me produce a basic framework for a program that will "kind-of" do the job, including in a programming language that I do not know well? By all means.
The particular issue is the assistant is not sloppiler then the person using it, and it is less sloppy than the other alternative, that is no code at all.
This is common thing we in people selling stuff. Engineers think a product has to be perfect, they never develop a perfect product and never sell anything. In the meantime some salesperson has made a billion of their imperfect crappy product.
It doesn't produce correct code, we all know that, but ChatGPT4 gave me incorrect answers that showed me where I should look and that unstucked me several times working with LLVM 15. It provided me much more value than the 20$ I paid for.
Just wrote something similar with more words. Getting unstuck and being something to bounce ideas off even when its replies aren't great often provides enough value to justify the cost.
I think people assume CoPilot is built to be your pair-programming coworker. Maybe that's Microsoft's fault for allowing that hype to go unchecked.
Honestly, the correct way to understand this is, it's just Microsoft's IntelliSense v2.0 rebranded with an extra machine learning system
Instead of autocompleting lines of code from an index, it's autocompleting entire complete working functions based on what it learned from GitHub.
IF you learn how to use it, it can save you hours of writing repeatable code. It should almost never be used to generate completely new code out of thin air. That code is quite dangerous because it looks logically right, and at quick glance looks exactly like what you need. However, it's completely wrong and could cause catastrophic system failures if left untouched. Then you waste the time you previously saved trying to figure out what the CoPilot spit out.
This is accurate to my experience with CoPilot. I've found if I type a function name, it will quite often autocomplete the entire function for me, correctly referencing variables that are available in scope, and naming parameters well. I haven't used it long enough to say how much speedup it's giving me, but it feels more like an incremental increase than an order of magnitude say. I am curious to try it on larger pieces of code to see if I can get more out of it.
The hidden error scenario is real -- on the other hand, I've also seen Copilot output code that successfully accounts for edge cases I hadn't yet thought of.
I think with GitHub Copilot I save 10-20 minutes a day and those moments it feels Like a superpower. For me personally I know what I'm doing and if the AI gets me sometimes faster there thats a personal benefit I appreciate.
I guess you could classify myself as "not a programmer" since I don't do it daily, and I mostly make scripts and small web APIs in python for tinkering around with IoT stuff.
ChatGPT has made it incredibly easy for me to program quick solutions to problems.
"Write a simple Sanic framework app that has a POST request with route '/logtemp' that accepts two parameters - a datetime and a value between from -40 to +40. - the route will then call a function that inserts these values into a Sqlite database with method signature logTemperature(datetime, temperature)."
I have to do some additional coaxing obviously (and prompt it for edge case recovery, etc. etc.), but it takes the mundane-ness out of learning the framework for something I'm not planning on selling or scaling up - not considering any other problems that can go wrong blindly inserting data into a database, etc. etc.
Maybe for full-time programmers who need to maintain complex codebases with many different source files, etc. - I could see that AI might not be able to help with that, but given enough time I'm sure we'll see AI software that will absorb your code, run/scrutinize it, and come up with recommendations, etc. you can make to it to make it better. (maybe automatically!)
I sometimes work in a co-working space, there's an (I think) architect sitting there who does a lot of 3D/modelling stuff. From what I've heard it involves python/c++ for creating and rendering his models. He knows the math, and he really doesn't care about maintainability: Either it looks good to him, or it doesn't.
For him, ChatGPT and similar stuff works great. And I can totally see why. But for maintaining a full-time complex codebase where the code is less about 'make it work' but rather about 'make someone in five years understand what and why things are happening' it still seems like a no-go.
There's a class of programming problems that are "keyboard-hard", in that they're a pain to type out but fairly easy to verify correctness. For this set of problems I've found coding AI assistants are sooo useful.
> There's a class of programming problems that are "keyboard-hard", in that they're a pain to type out but fairly easy to verify correctness.
Shouldn't the existence of such problems rather be considered to be a "bug" (or less pejoratively: "important missing feature") in the programming language that you use? Or perhaps you use a programming language that is a bad match for the problem that you want to solve?
I keep wondering about this - the people who say that AI assistance makes their work easier generally talk about all the repetitive boilerplate they have it generate, and I just think: why are you doing that in the first place? If your code is full of repetitive fluff, aren't you missing a layer of abstraction somewhere, and isn't it going to be a nuisance to maintain? Isn't this a problem your language should be solving?
But clearly there are a great many people for whom this way of working seems normal.
Web stuff. HTML and Json etc is a lot of boilerplate. Same with crud controllers for models. Stuff like that. I treat it like a junior/intern. I decide the structure and copilot gets to type it. With about the same hit or miss chance :p
I've definitely experienced that ChatGPT workflow here where you just kind of constantly fighting it to get the right answer and then give up disappointed.
However, my most recent use of ChatGPT was to create a very large SQL MERGE statement. I could have coded it by hand but it was long and the MERGE syntax is sufficiently unfriendly so I just pasted in the table structure and what I wanted and it generated the several hundred lines of code I needed. Boring tedious stuff.
Yeah I've experienced that with ChatGPT too. But my experience of Copilot is much much better. Probably partly because it's just there in the background and you don't spend any effort trying to convince it of stuff. It just occasionally comes along and saves you 20 minutes of tedium.
The autocomplete interface is also pretty good for allowing errors - it's already set up under the assumption that the suggestions are likely to be wrong, so it doesn't feel as bad when copilot suggests nonsense.
Okay. So, really basic things like unit tests, forecast models, or VS Code Extensions Not useful? Hard sell.
The reason why ChatGPT isn't "good at code" is because it just needs more training data and feedback. That's it. And it appears that this is a decision from above to not give GPT-4 that kind of training data (for now). One can guess as to why (...job market).
Needing more training data seems wrong. Imagine the space of all programs. Can we agree that one can only train a model on a given subset of that space? Now, imagine wanting a program P that solves a particular problem, and that the program P is not in the training data. How does more training data guarantee that the output is P and not a neighboring P' that is almost correct, but subtly different and therefore utterly wrong? I think (and the author seems to agree) that the most we can hope for is a less sloppy approximation, not a correct program.
I guess the farm tractor killed way more jobs (from potato harvesters, cereal harvesters, ...) than AI would even in the most utopian ways. But that doesn't matter: Both tractors and AI would and did shift wealth from the working class to the owning class. So I don't get why the "above" would try to not give GPT-4 the training data that they currently own anyway...
Agreed that ChatGPT can be a bit of a hit or miss when you ask it to produce code. But, I'd say a good 50% of the code I recently wrote was actually created by AI and I'm a lot more productive thanks to it.
3 big use cases for me so far:
- Github Copilot is just great. Often it helps fill in the code I was just about to write (or Google search). It just saves time, period. Plus, there's been at least a few times when I was ready to throw in the towel at the end of the day. But carried through as Copilot suggested the next line or implementation of a method I wanted to just create a placeholder for.
- ChatGPT for a project in an unknown domain. A few weeks ago I wanted to create a Chrome extension. I've never done it before and didn't know where to start. I asked ChatGPT and it delivered a great interactive tutorial with just the right code to get me started (I had to fix a few bugs that ChatGPT helped debug). Am I an expert in Chrome extensions thanks to it? Hell no! Have I created a working Chrome extension in a very short amount of time? 100% yes!
- ChatGPT for debugging. When I search for an error and get not-so-relevant Google search results, often ChatGPT can suggest rather relevant things to look into given an error message.
Of course, your mileage may vary, but saying AI does not help programmers based on a quick test of it not implementing things perfectly seems a bit surprisingly shortsighted I'd say.
Agree entirely with your assessment. I find Copilot / ChatGPT to have varying degrees of utility, but neither tool ever makes me less productive. To your point, they do generally make me more productive, as they can help me debug / explain errors and code I'm unfamiliar with way better than Google can, assist in a new problem space and do some basic introductory scaffolding, and they help me write boring ass code more quickly (e.g. lots of unit tests with different conditions). Copilot especially does a great job at understanding the context of what I'm working on.. suggesting imports or autocompleting entire test cases based on my test description string.
It isn't quite "read-my-mind" level _yet_.. but it did feel magical for a while until I got used to it as part of my workflow.
I love your 2nd point and in my experience this is where ChatGPT excels for me. I wanted to start learning Swift and being able to ask ChatGPT for specific examples on how to do XYZ, copy and paste the code, see the result, tweak, ask follow on questions, and for the most part it just worked. Is it perfect? Not by a long shot, but it's a great start.
For sure! I think I learn best by trying to build something rather than following a tutorial. ChatGPT just makes that so much faster to jump straight into that.
Thanks! That is the first description I've heard of a use for ChatGPT which actually sounds like it would make my work easier. Perhaps I'll give it a try.
"In typescript, Write me an express POST endpoint that takes in a JSON payload, assigns it a unique id of some sort, and uploads it to an s3 bucket"
"To continue on with the last request, in typescript, write me an express GET route that takes in an id of the JSON file that the POST request above uploaded, downloads it from s3 and sends it to the user."
For problems with well defined constraints, ChatGPT4 is amazing. Of course I had to rewrite all the error handling logic, and fill in some details, but it saved me a lot of time looking up APIs.
The flip side is, it originally tried writing against AWS SDK2, and I had to ask it to use SDK3. If I hadn't known about SDK3, I would've had less than optimal code.
Similar thing when I asked it to add ajv validation to an endpoint, I hadn't done that in a couple of years and I knew it'd take me awhile to remember exactly how, while ChatGPT pushed it out in a few seconds, but with non-optimal code (didn't use middleware). Because I already knew what it should do, I was able to ask for a correction.
I have a genuine fear for Junior developers using ChatGPT and never going through the struggles to learn the tools and technologies that makes a good Senior engineer.
With the out-of-date SDK, I had a similar experience. ChatGPT got me started with ManifestV2 for the Chrome extension and I found out it's getting deprecated and I should really use ManifestV3. But you know what, I asked ChatGPT how to update from ManifestV2 to ManifestV3 and it gave me the steps and things to fix. I had to do a few iterations as new errors were coming up and some things needed a bit of a refactor, but it was all done quite fast.
The fear of juniors skipping out on key learnings, or even perhaps having a hard time finding jobs in a few years is definitely interesting and something I'm super curious to see how it will go...
Yeah I tend to agree. I also feel like the majority of my deeper software knowledge has come from reading/modifying existing code, debugging and reverse engineering rather than actually writing code.
I think it's kind of right though. Like we're in the midst of a generation of developers most of whom can't seem to be productive without stackoverflow or Google open in a tab somewhere.
>James Gosling wants to punch the "Real Men Use VI" people.
>"I think IDEs make language developers lazy." -Larry Wall
>"IDEs let me get a lot more done a lot faster. I mean I'm not -- I -- I -- I -- I -- I'm really not into proving my manhood. I'm into getting things done." -James Gosling
Agreed, for me it's on multiple occasions fixed some of those errors that are syntactically correct but can't be seen by the IDE or the interpreter/compiler, like forgetting to change some variable when copy pasting a section or calling the wrong function of the correct type. Stuff that can only be spotted when thinking about code semantically.
GPT 4 is also a serious CSS master, so that cuts so much time from trial and error there.
Current drawbacks though:
- the 2021 cutoff is very apparent, it's terrible at newer stuff since it can't pull from many examples (browsing mode helps, but it usually fails at finding the info it needs)
- it really can't help with the typical workflow of editing some small thing in a huge codebase because there's no way you can give it enough context for an answer that isn't based on heavy speculation
- when doing too much back and forth it eventually starts to cut tokens and no longer knows what the original question was; sometimes it's not an issue but other times it just goes off topic
Definitely experienced all 3, but still getting more boost than drag overall.
The large codebase context might be somewhat solvable and I've seen projects that use embeddings to find the relevant bits of code to feed GPT to help it with context. No clue how well any of them work though, haven't tested them yet.
I've definitely noticed times when the conversation gets cut off and it can't "remember" the previous messages. Often, it results in a loop of ChatGPT giving me a solution, me getting an error and sending it back, then ChatGPT being terribly sorry and suggesting a new solution. Repeat 3 times and often we make a full circle to the first solution in this way...
I know right? To me it feels like cheating in an exam, where I ask a know-it-all who gives a straight answer without me understanding it, but then it turns out that the know-it-all didn’t know it very well either, but just appeared confident, so we both failed the exam.
I find it's great as long as what you're doing is very straightforward and boilerplaty. I find I have to go and re-write a lot of what it outputs though, since it tends to be for a lack of a better word, noodly. You often have to invert conditions and move stuff around for Copilot's suggestions otherwise everything has 7 levels of indentations and redundant condition checks.
Often with this re-write, the Copilot solution isn't really saving any significant time, as you could have just written it correctly to begin with.
> ChatGPT for a project in an unknown domain.
I'd say this is true for problems that are well explored with plenty of tutorials. Ask for help doing something that's even the slightly off the beaten path and you'll get entirely hallucinatory APIs.
Let's say you wanted to write a Parquet file in Java, for example. It's not a particularly strange thing to want to do, except I've never managed to get ChatGPT or Phind to produce a meaningful answer to that inquiry. You get correct-looking answers, except they use code that doesn't exist.
> ChatGPT for debugging
This I do agree with. You can just give it a function and ask "where is the bug in this code?". If there is a bug it will say so. If there isn't a bug, it may sometimes also say there is a bug, but it's pretty easy to verify and dismiss the answer at that stage.
Regarding your criticism of Copilot: I think the productivity-related outcome of the results varies from person to person. The exact results you mention help me in a way that I acknowledge is somewhat irrational. The mental load of verifying and manipulating conditions (that are already correct) is much lower than writing them.
As others have said, this article is written as if GitHub's Copilot + VSCode integration doesn't exist, and I think the author should get that going before concluding, "AI Does Not Help Programmers."
It saves me a decent amount of rote implementation. I read up on the APIs, I understand the pattern I'm supposed to implement, but then Copilot actually does it for me. It's not a world-changer, but it does save time, it does "help".
And not for nothing, at least once I've pasted a script into GPT4 and asked "What's wrong here?" and it correctly identified I was using `[` instead of `[[` for a Bash conditional. This was code that had been working for years (AWS must have updated what version of Bash it was running CodeDeploy through), I never would have thought to check something like that. Realistically saved me an entire day hunting that down.
I find copilot hallucinate so many variable names, function names, etc that I find it borderline at best for generating code.
I spent about and hour debugging before I realised copilot had put two function arguments in backwards, f(b,a) instead of f(a,b). Yes I should have read it more clearly, but after 4h of working, it just slipped through.
Copilot has "intelisense++" is more useful, but even then the ux is kinda horrible where it inserts random extra quotes at the end of strings and whatnot.
Copilot chat/gpt4/bingai is a lot lot better, but it needs to be integrated into vscode and actually be aware of the entire code base.
I'm 97% sure that just using static analysis to provide all the relevant type definitions and function signatures as context for code completion in LLMs alone will be a massive value-add. I'm literally doing that by hand right now to GPT-4, and it works.
And I think there's more stuff that can be done where one sets up an automated cycle of (1) prompt LLM, (2) type-check completions, (3) construct prompt that incorporates type checking errors, ..etc.
I really think that this, combined with types written with the "make illegal states unrepresentable" philosophy, will be great.
I think that for the immediate future, AI will be more of a help to non-programmers who need to do simple programming tasks than to actual programmers.
I say this as a PM who is regularly using ChatGPT to prototype things and to write scripts to automate things in my side business.
Folks have been talking about no-code platform for as long as I can remember, but they've always been too minimally-featured to be useful, or they actually required significant programming knowledge. ChatGPT, in my experience, bridges the gap, at least for simple, standalone tools. I expect it will get better and better as a tool for non-developers to build simple things.
> The title of this article is rather assertive. Take it as a proposition to be debated [...] The main immediate goal is [...] to spur a fruitful discussion to advance our understanding beyond the "Wow!" effect.
OK, I already know where this is going so I'll just skim the rest.
Hmmm... as I suspected, I can't see how this article is any different to:
"AI Does Not Help [xyz]" with cherry-picked examples to prove a point.
In fact, I'm pretty sure I've been reading similar articles several times a month since ChatGPT was released.
Here is my "proposition to be debated":
"Articles about how AI does not help [xyz] do not in fact help anyone"
ChatGPT is awesome. More often than not, I ask it to do something and it produces something that works in some way on the first go. Then I debug it, but I debug it using ChatGPT and, in almost all cases, get to working code faster than I could have if I were simply writing it from scratch. It's also much more enjoyable and I can do other things while it types its answer.
Perhaps I find it so useful because I'm actually using it for real world tasks instead of trying to contrive an example that demonstrates its usefulness or lack thereof.
I have bumped up against its limitations from time to time, and sometimes after a while working on the same thing it just totally loses the plot, but by and large I get phenomenal results. That being said it may be good at some technologies but not others. I spend quite a bit of time working on JavaScript, specifically Google Apps Script and NodeJS (not frontend) and BigQuery SQL, but I have also used it for bash scripting, generic Linux type config/sysadmin stuff, PHP stuff, API development.
Maybe if you're writing something more eclectic then it struggles.
I get what the author is saying here, but I have to respectfully disagree.
> I would love to have an assistant who keeps me in check, alerting me to pitfalls and correcting me when I err. A effective pair-programmer. But that is not what I get. Instead, I have the equivalent of a cocky graduate student, smart and widely read, also polite and quick to apologize, but thoroughly, invariably, sloppy and unreliable. I have little use for such supposed help.
> Fascinating as they are, AI assistants are not works of logic; they are works of words.
> They have become incredibly good at producing text that looks right. For many applications that is enough. Not for programming.
Meyer may be right in that currently LLMs are illogical therefore unsuited to programming complex software, but programmers can still find use from LLMs by delegating to it simple programming tasks like glue scripts.
People should use it for small automations, especially those which aren't mission critical so it's okay for it to make a mistake.
The kind of would you would delegate to that hypothetical cocky grad student.
Meanwhile we have famous programmers like Simon Willison, co-creator Django saying this[0]:
> If you're just starting to learn software engineering right now but you're considering dropping it because you think the field might be made obsolete by AI, I have an alternative approach to suggest for you:
> Start learning now, and use AI tools to learn FASTER
> I wrote about my experiences using ChatGPT and Copilot to help learn Rust back in December
> I've since started to get more ambitious - I'm using it for all sorts of other languages, like AppleScript and zsh and jq
I just canceled Copilot and I'm more productive now that I'm not hesitating and waiting to see if Copilot does something.
COPILOT PROS
- Good at boilerplate
- Good at unit tests
- Fairly good at pasting from Stack Overflow
CONS
- Most of the time it does nothing
- Large code blocks pop in and out while I'm typing, which is distracting
- Sometimes it correctly guesses what I want, but the code is completely wrong with non-existent variable and method names
- Visual Studio has 3 or 4 other "helpers" and they can seemingly all active at once, making hard to even see what I'm doing (Intellisense, Intellicode, CodeLens, ???)
EDIT: I include writing prompts and reviewing Copilot output as hesitating/breaking flow.
It’s hard for people to acquire new skills if they go into using a new tool attempting to confirm their own preconceived biases about how bad the tool is for a given task.
If you are a programmer who finds no use in AI, try asking it things like this:
“how do I….”
“how does this work”
“explain this code”
“convert this function to typescript”
“what’s the maximum decimal of uint16”
“difference between this and that”
“give me an example of”
“what are the arguments to this function/method”
“what causes this error”
“explain this code”
“given this data structure, how do I get the third row, first item”
“how do I centre a div”
“create a C header file for these functions”
“what’s the command to compile this code”
“what’s the regex to get lines containing foo”
“ffmpeg command to convert X to y”
“given this sql table, write a postgres query to get the first to 100th row and return the data as json of this form”
“make 1000 rows of sample json data with fields name address phone”
“write a sed command to search and replace X with y”
“create a cmakelists to compile this”
“write a python program to compare two directories A and B, if a file is in both A and B, then ensure that in B it is the same subdirectory as A, create the directory if needed”
etc etc and critically important:
“that didn’t work”
“another approach”
“any other ideas?”
If a programmer sees no value in any of these sorts of AI interactions then honestly they're not worth being on your team - they're wasting productivity.
The point is not that a developer does not know how to do a given task, the point is that certain programming tasks are just hack work- it's a waste of time to be hand coding them - let the AI write a first pass for you and debug it and move on to the next thing. And when you are doing hard things, breaking new ground, learning new stuff, then the AI gives quick answers to the multitude of questions that will be coming up in your head. Sure, sometimes the answers are wrong but that's a small price to pay for the number of times the answers are right, or point you in the right direction.
Also, certain technologies are incredibly well suited to programming via English language - for example regular expressions - grep/awk/sed - I've always dreaded writing regexes because I know what I want but it's such a chore to hack through finding the right syntax. You're burning your employers time it you don't use AI to drive such tools. What could be better than saying "with grep scan all python files recursively and case insensitive for the word 'import' and return the file name and the relevant line and also the immediately previous and after line".
AI programming is programming via pseudo code. How can a developer find no value in that?
I don’t mean to sound disrespectful, but out of all examples you could’ve picked, almost all of them scream that your programmers are very unproductive as a baseline.
So your programmers know every ffmpg command by heart, never forget regex syntax for any dialect, etc? Do they never make mistakes and never ask for help locating them? These sound like mighty fine programmers.
There exist quite many programmers who concentrate much more on a single technology stack which they spent a lot more time learning.
The given examples where AI might be useful are much more helpful if you have a rather shallow knowledge of the technology that you use (for example if you switch the technology stack very often).
Your comment suggests perhaps you are not a programmer. This is what programmers do all day - ask questions like this, solve problems like this and implement functions like this.
As I said: "The point is not that a developer does not know how to do a given task, the point is that certain programming tasks are just hack work- it's a waste of time to be hand coding them - let the AI write a first pass for you and debug it and move on to the next thing."
Almost all of your queries are simple google/documentation/“ffmpeg -h” lookups. AI doesn’t do anything here but add uncertainty whether the information is correct.
Anyway, I don’t think you understand what costs programmer time. The tasks you mention do not cost them hours, they don’t even add up to hours.
fwiw I am a programmer, e.g. I have almost 3 decades of experience in c++, which, according to your submission history, you just started learning? Nothing wrong with that, but then I’m not sure why you speak like an authority in programming by denigrating others’ ability and making hiring/firing recommendations.
Considering that your tone is consistently hostile, I don’t want to engage with you anymore. For your consideration, you probably alienate a lot of people/talent in real life, too.
And again “fwiw” as a teen I used to translate and distribute Japanese dramas that wouldn’t see a release elsewhere. I don’t think you care though, and just try to denigrate again.
Using AI to reduce cognitive load is both a gift and a curse.
We can use ChatGPT to write essays for us. But the reason why we write essays is because the act of writing exercises our critical thinking and communication skills. Offloading that work to AI defeats the purpose. It's like going to the gym and then using a robot to lift the weights for you.
The same argument applies to programming. I think the most important skill in programming is the ability to "think in code", i.e. to be able to write, understand, and debug code without any tools other than a plain text editor and a terminal. The only way you build this mental muscle is by doing the reps. The risk of having tools do the work for you is that they ultimately become a crutch.
Of course, there are cases where using tools to increase productivity is a net benefit. An expert essayist can potentially use ChatGPT to synthesize information without compromising their thinking process. An expert programmer can potentially use Copilot to automate certain rote programming tasks. I just think we should be careful not to use tools in a way that compromises our basic mastery and foundational knowledge in a given field.
This is probably an unreasonably hard problem, but I asked ChatGPT to write me a boot sequence for an AWS machine that would write "hello, world" to the serial port then terminate the instance.
What I got was some fairly generic stuff about bootloaders, and some hallucinated links to non-existent AWS Nitro whitepapers.
I was probably expecting far too much, but it was disappointing given reports of it approximately solving problems out of whole cloth.
There's an interesting parallel between this critique and bad interviewing practices - the kind where the interviewer has a toy problem with a particular "correct" answer in their head and asks the interviewee to figure it out. A lot of the prominent critiques of AI seem to be taking the form "LLM are based in statistics, so they fail to produce strictly-defined solutions, therefore they have little value", which is as close to a straw-man argument as you can make.
Instead, I tend to value critiques that check whether LLMs are useful for the huge number of challenges that we have as programmers where we have to infer 'best' solutions from under-defined problems, or where we have a large set of reference data but need to infer patterns/correctness - those challenges are just as hard (if not harder) than implementing algorithms precisely, so
- I accept that LLMs aren't good at implementing specific algorithms
- Can they help write exhaustive unit tests based on code and/or a written spec?
- Can they help identify potential errors in your best attempt at a solution, even if they can't 'fix' the errors?
- I can think of a hundred ways to get use out of "a cocky graduate student, smart and widely read, also polite and quick to apologize, but thoroughly, invariably, sloppy and unreliable" - that's a skill that programmers now need to develop, but there's a huge amount of potential in such people, and an analogous potential in LLMs.
ai sure can't program for us yet (at least not in any appreciable level; speaking as a senior engineer). But it is quite nifty for sketching things or quickly getting some syntax or boiler palate down. It hasn't helped me solve any non-trivial problem but it has saved me a fair bit of trivial work every few days
Does anyone remember the Slashdot Spam Solutions Checklist?[1]
Here's my effort to try to build an LLM is Bad at <TASK> Checklist (:
---
This critique of LLMs for writing software is
(x) ill-informed ( ) outdated ( ) biased ( ) shortsighted
and fails to work because of the following reasons. (One or more of the following may apply to your particular critique, and it may have other flaws that are specific to different LLMs or development contexts.)
(x) Relies on ChatGPT rather than exploring alternative, better-suited LLMs
(x) Misrepresents LLM capabilities by using single-shot examples
(x) Neglects the benefits of prompt iteration and refinement
(x) Disregards the value of experimenting with diverse prompt styles
(x) Overlooks LLMs as code review or debugging assistants
(x) Ignores the potential of ReAct, chain of thought, or other prompt-enhancing techniques
(x) Omits crucial experiment details, hindering reproducibility
(x) Unfairly demands second-order explanations for first-order errors
(x) Fails to recognize that LLMs can benefit from standard software development practices (testing, specification, etc.)
(x) Underestimates LLMs' potential for generating pseudocode or high-level design outlines
(x) Dismisses LLMs as valuable documentation or tutorial creators
(x) Overlooks LLMs' potential in brainstorming, creative problem-solving, or idea generation
( ) Underappreciates the continuous improvement of LLMs with more training data and fine-tuning
(x) Ignores the value of LLMs for assisting novices or non-programmers in understanding code or creating simple scripts
(x) Obsesses over LLM-generated executable code, ignoring broader software development tasks where LLMs could shine
Additionally, your critique may face these philosophical objections:
(x) Similar critiques are easy to make, yet none have conclusively refuted the value of LLMs for software development
(x) Focusing on current limitations ignores the rapid advancements in LLM capabilities
(x) LLMs should be seen as complementary tools, not as replacements for human developers
(x) Collaboration between LLMs and humans can lead to innovative solutions and improved software quality
(x) LLMs can democratize access to programming knowledge and resources for a wider audience
Finally, this is what I think about your critique:
(x) Sorry, but your critique doesn't hold up against the potential benefits of LLMs in software development.
( ) This is a misguided critique, and you're missing the bigger picture.
( ) Nice try, but you're not going to derail the progress of LLMs in revolutionizing software development!
---
[1]: Example https://tech.slashdot.org/comments.pl?sid=10377045&cid=54065831
Thanks!. The canonical url is much better than the one I found. I've seen it mentioned that this originally came from Usenet groups. I'm pretty sure it wasn't created in this final form, as I recall seeing it evolve in the early Slashdot days too.
Like the author, I want an assistant that can reason about the problem, not just crank out plausible-looking code. ChatGPT et al. can produce code that seems plausible, and may actually work. But that happens because it got trained on a vast corpus of code, and most programmers write code that already got written thousands of times before by other people. It doesn't happen because ChatGPT has unique insight into the problem to solve, or into how to write code.
In his long and excellent explanation of LLMs, Stephen Wolfram observed:
> So how is it, then, that something like ChatGPT can get as far as it does with language? The basic answer, I think, is that language is at a fundamental level somehow simpler than it seems. [1]
I think that most programming is, at a fundamental level, simpler than it seems to most programmers. As a programmer's skill and experience increase tools like ChatGPT offer less utility. Junior programmers struggle with even simple things. But delegating those things to an LLM prevents the programmer learning the most important skill: problem solving. Similarly having someone do your homework and write your papers gets you a good grade, but you haven't accomplished anything -- you just ran in place by delegating the appearance of work and failed to actually learn anything.
As other people noted in the comments in this thread, if you get value/save time by having ChatGPT generate boilerplate and unit tests and so on, ask why you do that in the first place. I have the same opinion about ChatGPT/LLMs writing memos, emails, term papers, articles -- those artifacts cannot have much real importance if they get delegated to a tool that can only produce plausible text. The actual value of writing and communicating gets removed, only the artifact and the appearance of work remains.
ChatGPT v3.5 does have this problem where it constantly apologizes, when you as a question about the answer it provided.
It feels like it made an error by not having answered the question as expected, and then apologizes for it. This is a back-and-forth, constantly issuing apologies:
---
user -- Why does the new device need an IP in the VLAN's subnet?
ChatGPT -- I apologize for the confusion in my previous response. If the new device is only acting as a bridge or switch between the two computers on the different VLANs [...]
user -- These 3 steps you mention are required for the new device to act as a bridge?
ChatGPT -- Apologies for any confusion caused. You are correct, the three steps I mentioned earlier are not specifically required for the new device to act as a bridge. [...]
user -- Now you are confusing me. Let's start anew, but keep the history in mind. [...]
ChatGPT -- Apologies for any confusion caused earlier. In the scenario you described, where computer A and B are on different subnets
---
Luckily GPT-4 doesn't do that, but in 3.5 this also occurs when asking certain programming questions.
This thread is filled with anecdata so I'll provide mine.. I didn't enjoy using copilot that much. Or gpt. But it could just be due to ingrained coding habits. I find that when I code I'm thinking mostly about design problems. By the time I know how I want to code something the effort to actually do the typing in is the easy part and rather enjoyable. With copilot it was rather good at filling in sections of code but that changed the experience of composing code to having it autocomplete stuff, I would check its logic. Sometimes I would still realize I needed to redesign something so I would have to axe or modify what copilot had wrote. I just didn't find that flow to be enjoyable. I tend to believe it's a matter of practice to get the most out of these AI systems. Just like someone on a scooter needs to learn to kick off with their feet, glide and steer. However for me I still need to feel the ground beneath my feet
The "right" answer, as with everything, is probably a balance between full AI generation, AI copilot, and full human coding. One has to just be humble and try and adapt and do new things to reach that balance.
Well I just learned functional programming, specifically Ramda using nodejs over the weekend, thanks to ChatGPT. Didn’t even know I needed it, or what it was, but I’m working on a series of data transformations that help me clean data and oh man, Ramda makes everything so much cleaner and understandable.
ChatGPT introduced me to it, then helped me debug and write a bunch of code as I had trouble wrapping my head around functional programming.
But sure, it’s all in my head and ChatGPT wasn’t helpful at all?
Compared to what or whom? Normal people don’t have brilliant mentors, and don’t understand complicated docs at a glance.
Authors like this miss the point because they’re already brilliant. ChatGPT is for stupid people like me, not for brilliant people like him.
I already outsource some production module to cgpt. It help me made complex postgres CTE queries involving json data type. gen PHP code for that module. cgpt produce good result as long as you feed decent prompt (detail, context, output samples, etc).
I use copilot daily. I consider it a big help when it fills in unit tests for me. It removes work that adds no value. In other words, copilot adds value. It has also been a big help when I do something that is fairly common but is my first time. I have predicted hours to work up a new feature before and was surprised to have it done in minutes after typing...a character.
I stopped using ChatGPT after it was adapted to bing. Very little, if not zero, help now. Copilot seems to assess and track context and knows what you want to do as you move across files and domains. Solid tool.
reply