These days ‘AI’ is everywhere, including in software development. Coming hot on the heels of approaches like eXtreme Programming and Pair Programming, there’s now a new kind of pair programming in town in the form of an LLM that’s been digesting millions of lines of code. Purportedly designed to help developers program faster and more efficiently, these ‘AI programming assistants’ have primarily led to heated debate and some interesting studies.
In the case of [Jj], their undiluted feelings towards programming assistants like GitHub Copilot burn as brightly as the fire of a thousand Suns, and not a happy kind of fire.
Whether it’s Copilot or ChatGPT or some other chatbot that may or may not be integrated into your IDE, the frustration with what often feels like StackOverflow-powered-autocomplete is something that many of us can likely sympathize with. Although [Jj] lists a few positives of using an LLM trained on codebases and documentation, their overall view is that using Copilot degrades a programmer, mostly because of how it takes critical thinking skills out of the loop.
Regardless of whether you agree with [Jj] or not, the research so far on using LLMs with software development and other tasks strongly suggests that they’re not a net positive for one’s mental faculties. It’s also important to note that at the end of the day it’s still you, the fleshy bag of mostly salty water, who has to justify the code during code review and when something catches on fire in production. Your ‘copilot’ meanwhile gets off easy.
“[… ]their overall view is that using Copilot degrades a programmer, mostly because of how it takes critical thinking skills out of the loop.”
I don’t know … when I use Copilot while developing something, I need to be especially vigilant and think critically. Otherwise that thing does whatever it “wants”, not what I want it to do.
Agreed, rather than taking critical thinking out of the loop, it brings in vibe coders without critical thinking INTO the loop.
If you stop critical thinking, it’s on you. Sure for simple stuff, or configuration stuff it can reduce the time you spend looking up, but when it comes to writing code that’s not in the training data, it’ll getting more and more confused or ‘overshoot’ the solution by a mile. More and more exact prompting helps but not always. The more you know, the more you can specifically direct it, but at some point there’s not much point in asking the LLM to do the work if it keeps getting things wrong. I guess it’s most useful for mid level developers. Juniors may learn the wrong patterns from LLMs, seniors are more slowed down than sped up by LLMs. I still find myself spending most of my time in documentation and researching ways to do it and weighing the pros and cons. But boiler plate code and unit tests is best left done by LLMs. It’s tedious and not very interesting to do that yourself.
yes
GitHub’s CoPilot can barely code. If anything, might make you a better programmer because you have to constantly fix GitHub CoPilots output. One word…suck.
Hey, it’s the RAD argument from a few decades back!
“Oh no, the “unskilled & untrained” will be able to do what we can do, but easier and faster! Oh no!”
“…but when it comes to writing code that’s not in the training data…”
Code that’s not in the training data? What does that mean?
Code from planet mars🤣🤣
I don’t use AI and the problem is the software does what I tell it to do, not what I want it to do.
Lol, snap
And it’s expensive. I pay $60/month for what? frustration, arguments, false assurances, lies, doing it’s own thing… It’s like a wild horse trying to be tamed. But the funny thing is can’t do without it. I wish I could sell software like that.
Trust me, a wild horse is way more fun than copilot
What exactly is $60 a month?
You can switch to Claude code, it’s far better
Came here to say pretty much exactly this.
I’ve become far better at coding since using AI because I take time to learn WHY it does what it does, which always leads to deeper lessons in software engineering
Exactly,, you need to spend time and ask the right questions.
I’d say just asking questions consistently leads to better results. Asking the right questions comes with the practice.
True. I’m not really a programmer but I learned to program because of Ai. It keeps getting things wrong and it makes me frustrated in the end. So I just asked why it’s wrong or having an error so I learned to correct it myself lol.
Copilot and ChatGPT are good enough for those of us who aren’t programmers but who need internal applications that can help our teams do their jobs more efficiently. For example, I can use AI to build a basic HTA app that can inspire the IT Department to build something more robust in C++ or Python that could be deployed company wide in less than an hour. Eventually AI will be good enough to do all of the heavy lifting. It’s inevitable.
I have been working together with ChatGPT in Xcode. I don’t use it for coding. And I wish the autocomplete wouldn’t use it either, because I find that the use of my Delete button has increased 10-fold.
But I had a timing problem in my code. I was showing two alerts back to back, but the second wasn’t showing. I had a good idea of what the issue was, so I used it to test ChatGPT with the following conversation. The first questions were to set a basic context so that the GPT was somewhat aware of my code.
“can you explain structure AlertCoordinating?”
“In AlertCoordinator, when is currentAlert set back to nil?”
Then I tried to narrow it more down.
“how does the timing here impact the presentation of multiple alerts?”
And to my surprise, the GPT told me how the timing works, and already came with an explanation “The Problem With Back-To-Back Alerts” here, and “Typical Symptoms”, and “Best Practice: Add a Short Delay”. So apparently I had loaded it successfully.
Adding a short delay is not a good practice at all, so I did not accept that and asked further:
“apart from using AsyncAfter, is there another way of better chaining alerts?”
And then it came with a bunch of alternative approaches, including the one I was thinking of myself and was seeking confirmation for.
“1. Use State to Queue Alerts”
“2. Use .task(id:) for Alert Sequencing”
“3. Use Combine/Swift Concurrency”
“4. Explicit User Action”
And it came with a recommendation:
“Recommendation
The queueing approach with a stateful alert queue is typically the most robust and SwiftUI-friendly method for chaining alerts, as it works within SwiftUI’s view update mechanics and avoids fragile timing issues”
And that was exactly what I was thinking and what I was looking confirmation for.
The GPT also came with a code snippet. But I already had another coordinator that was using such a queue, and the GPT came with code that didn’t look like that at all. And style consistency is very important if you want your code to be maintainable. So I manually implemented it (it was maybe 6 lines of code).
But to me, this was a success. It took me actually only a minute or 5.
So, asking a GPT to analyze your code and come up with suggestions is quite useful. But to ask to generate actual code is imo a lot less useful, because the GPT is just not aware of things like CLEAN programming practices and you can forget about SOLID. In the end a real programmer needs to take over.
But it did feel like I was pair programming, and that is nice if you are the only programmer of your code. ;)
It’s the tools that are aware of all that is where things will get interesting.
I agree, this is an interesting use case. The other day I asked Devin whether a registered callback in a library was invoked in interrupt context or not, and it directed me in seconds to the line in the ISR where it was invoked. The library doc was silent.
Since the beginning of collaborative coding, everyone I know dislikes code-reviewing or even the thought of working with code written by others so it’s been so perplexing to see people jump at the chance to constantly use code generated by what amounts to a first-year intern.
I like programming, not constantly having to second-guess code from somewhere else. Also reading documentation offers secondary benefits: you get your answer and you just might read something useful for the future.
I like code reviews and having other people point out mistakes or improvements for my code, it helps me improve 🤷♂️ (I do hate pair programming tho…)
I’ll tell you that I like both code reviews and pair programming even more.
All the dislike that I might feel for a code review comes from when somebody suggests something that makes me think “dang, why didn’t I think of that myself?”. And the dislike is in two places when that happens. 1) my ego. But more importantly: 2) it could take quite some time to change my code.
The first, well, if I learn something from it, then that averts the hurt to my ego.
The second is a business decision. And that might lead to some debate. Because time is money, and my code as it is works great too.
I am not talking about code reviews where someone catches a potential bug. I consider those good catches that save us from harm. I’m not so high on my horse that I believe I write perfect code, even though I have 30+ years of coding experience. I already wrote that ego is not such a big thing for me. I get my ego from successful releases, the adoption of my software by many people, and great reviews from them. :)
It’s being pushed to prevent labor arbitrage and make export of jobs smoother. AI is just another piece in that puzzle. They don’t care that it is crap
They don’t care that it is crap <<< this has always been true. If you deliver a complete rats nest solution quickly that just works, or a clean, well designed product that takes longer and costs more. . . they’ll opt for the rats nest every time.
This Audacity bug reports shows perfectly github copilot usefulness https://github.com/audacity/audacity/pull/8974
If I use LLM to help write code, the code gets written 10x faster and my brain still works at full speed. Everything just happens quicker – no reduction in critical thinking. In many ways, like Mark Topham aluded to, I feel more elevated in status from code monkey to …. errr ….. code [enter text].
lol
I have been programming for 60 years. I believe real software development comes in the DESIGN, not in the coding. Round-trip Engineering with Rational Rose and Embarcadero were so cool for me: Design the system, use UML, generate code, test, repeat.
Using LLM tools has been frustrating because it has been harder to define the myriad of standards that I require for my software. Even when I’m clear about “Hungarian-naming” variables, I can get two different versions of a subroutine from inputting the same requirements, and sometimes tweaks don’t consistently align with the generated code before the tweaks.
I’s coming, though. In a couple of years I will be able to set the requirements and grow my systems, according to well-defined constraints and parameters, and then improve on them with my highly-tweaked genetic algorithm to produce high-quality, precision, understandable, engineered systems.
I’ve only been programming for 55 years, and 100% agree. I intentionally never tried any of the commercial offerings, as I was more curious about how I could best use the technology, not necessarily what Microsoft, Anthropic, et al., have in mind. I’ve spent the past few months running various smaller freely available coding models at home. They work quite well at the one thing I spend too much time on these days, coming up with usable examples of how to set some obscure options needed by a random API in a particular context. And, there are models that do a decent job (if you ask the right way) of scoping out the tasks needed to complete and test a working project. I suspect a more hybridized setup with consultation, design, and coding models will eventually evolve into the truly high level specification languages that have been promised at least since I started.
Back in the 70s and 80s I worked on OS internals and graphics displays. During the 70s that was 100% assembly language, by the late 80s nearly 100% C. That transition was accompanied by similar arguments that it would degrade the skill levels of those who no longer had to use (or even learn) assembly language. Well, it did, but opened up the need for a bunch of new skills.
I believe that most people that dislike AI are taking a “bad” approach, I find AI very helpful as a tool just like Google is a tool and the helpful people at stackoverflow are tools (just kidding 😁 I love all the helpful people at stackoverflow).
To me AI (when coding) is kinda like Google+ w3schools, stackoverflow, framework docs etc etc merged together.
Tldr: imo AI is not your coding partner, it’s a tool
Call AI a tool and will come hunting you.. one day! People dislike AI because they are afraid of loosing their jobs. Obviously is improving really fast, in a few years we’ll be in a different level. Now we are talking like the artists one year ago when they said AI cannot draw fingers, and we have video generation.
It’s good your circumstances are like that. But a lot of compamies are forcing AI usage and are considering replacing jobs with it. This makes it no longer a tool but a negative disruption that may even lead to unemployment so not everyone can be cheerful and optimistic about it.
I have decades of programming experience and slowly introducing Copilot et al into my workflow. It’s fantastic. I still have to think through a problem in order to explain it to the LLM, but I can change my mind and ask for a refactor if I realize something is needed. I ask it to explain, justify or rewrite certain chunks of code.
But I used to be totally against it. It took some time to figure it out and not just throw my hands up and claim it takes just as much effort as doing it myself.
At this point, railing against it makes about much sense as refusing to use the features of a good IDE.
But you know, you do you. Use edlin.com for coding if you want, it’s perfectly possible to make excellent large-scale code that way.
Copilot is one of the worst LLM’s. But all LLMs make you dumber because they do the critical thinking, not you. If you’re still learning to code, you’ll be stuck as a junior dev forever because you never challenge your brain to work.
What programming language should you start coding in? Do you let your programming language do the critical thinking about when to release memory, or how to make a set? Do you let your programming language do the critical thinking about how to write assembly? It’s interesting to learn how to do many of the things our tools do for us, and sometimes useful, but ignoring the tools that make things quicker is not going to get you anywhere.
Copilot is not an LLM. What are you even talking about? You can choose between various llms and modes in the interface.
If you are finding copilot to be a net negative impact, you are not using the tool properly, after all your use of copilot is something you control. I don’t think we need articles about people who claim to know better than the AI, that doesn’t help us.
If you are finding vodka and cocaine doesn’t improve your driving, you are not using them properly.
This smells like the “No true Scotsman” fallacy.
This but unironically. Skill issue
Not that their response doesn’t have other issues, but I think your example is actually more apropos than you realize, and so, it is ironically self-defeating.
While I truly lament that education in formal and informal logic are nearly non-existent today, I also think a lot of people tend to use them incorrectly. Whether something is a fallacy may involve nuance.
This person cannot have committed an appeal to purity fallacy because they made no prior claim that was subsequently modified — that is the foundation where the fallacy occurs, and it is absent.
Even if we ignore that, your assertion is too broad for the fallacy. There is nothing wrong with qualifying use, and your response seems to pretend that things cannot have multiple uses in which some uses are negative/abuses.
That is the irony and self-defeating I referenced; while I’m quite aware you meant driving under the influence, cocaine, ethanol, and vehicles all have legitimate, low-to-no-harm uses. This proves their point: the harm came from how you used the three together. One could even still be driving safely after using ethanol and *caine drugs, such as by use as a disinfectant and local anesthetic, respectively. Your hypothetical is a direct example of their main point.
Disagree. Developers have a finite amount in of time, using AI to do the donkey work of creating base framework and such, gives the. More time to focus on what’s important.
AI output is only as good as it’s input.
I have been worried about this, as I’m sure we all have, but I try chatGPT from time to time when programming and I find it still requires a COMPLETE understanding of the code if you want it to actually work. Maybe some day this will change, but for now it does not seem at all capable of writing code that operates in a complex environment.
Really it’s just the same as the way it writes stories. Ask it to write a paragraph or 2 and it’s excellent. Ask it for a book and it becomes clear that it has no higher thought processes.
So why do I use it at all? I’m forced to admit that it makes writing boilerplate code much faster. Like if you want to make a HTML page with a table and some data, it can crank that out in 2 seconds and it will probably only require a couple of changes to work. If you want it to fit in nicely with your other pages, and work with whatever underlying architecture you have, it still needs extensive editing. You can’t do that if you don’t understand it.
I guess if you can break your problem down into a series of short code snippets with well defined input and output it can kind of “think” for you. But if you can do that, it’s almost always true that the implementation is already trivial.
Just like a calculator it is a tool, it can get you in trouble if you don’t know how to use it.
The status quo before LLMs was to spend a lot of time on stackexchange hoping to find the right answer.
A great use for LLMs is to quickly list what python libraries are relevant to what you need, and give you some snippets of code that can push in the right direction. Purely machine written code is obviously not a good way forward, but using LLMs as a tool, certainly is.
Instruction sets for CPUs can be turing complete. The outputs of LLM are not proven to be TC, they are based upon natural languages. LLM is not a “tool” it is a superset of tools being sold as a swiss army knife. An LLM is the knife factory itself
Oh sweet mercy, copilot is horrible. Can’t really do much of anything with it.
Cursor and Anthropic Claude 4, along with a healthy dose of requirements and documents for the project, works pretty dang well though. Still not trusting it blindly of course, but for hobby scale projects it works fantastic.
LLMs can be helpful for coding but in the limited context of mundane tasks. Things like refactoring code, transitioning to using a new API, or writing boilerplate stuff like command argument parsing requires labor but almost no thought. Beyond these kinds of limited tasks, you’re making more work for yourself.
The irony of some comments here. Software development is something usually done by a team, and has multiple levels of scale to consider simultaenously. Just bc an LLM gives you code and does some debugging, does not make your code maintanable or understandable. Further, the hoop jumping in vibe coding is an offset of effort and inversion of expectations. If you vibe code you spend 4 hours hammering down the prompt, which in 4 hours you couldve just done a design and wrote some code yourself. Now your boss wants to know what the hell your doing, LLM crowd cannot explain their code and get fired. The person who took time to write their own code doesnt have something that runs yet but they keep their job since they can explain what they did.
Vibe codding is a hobby not a viable career.
I am a senior software engineer and I use AI to code 98% of the code, the 2% is config files like .env and package.json. AI coding tools like Cursor are an extension of the user, the more skilled the user is at using the tool the more effective it will be. I’ve worked as a team lead managing 10 developers, and it’s similar work to doing the same with AI tools. I see the AI agent as a Junior developer, you need to instruct them on exactly what you want them to do, you need to bring in all the relevant context or show them where to find it. You need to clearly outline the task, if the task is a large task you need to break it down into a plan then execute on the plan. You need to review their work and understand everything that it’s doing to ensure it’s on track. you have to limit scope creep and keep it focused on a clealy outlined goal. If you’re building a project from the start it’s a lot easier than going into a pre-built project. The larger a project gets the harder it is to keep the LLM focused, the more diligent you need to be on your practices. If you want to be a 10x engineer then you need to understand and use these tools effectively. Having good PM skills is a is a requirement, and don’t get lazy pay attention to the details and understand everything the LLM is doing, if you don’t then instruct the LLM to explain it to you. Tests and linting are your friends set a max number of lines es lint rule to enforce good coding standards.
All fine and good except one glaring issue. The response to a prompt, and then the subsequent explanation of the reasoning behind the response, are 2 seperate traversals of the blackbox. This means that an LLM does not have any understanding whatsoever, it has states within a statespace which statistically correspond to inputs. These are not answers, rather suggestions.
Why does that matter?
If you’re going to be so pedantic, then it should be noted that the human brain is currently a blackbox, and our understanding of how it creates, uses, and recalls memories, is very limited.
It should also be noted that many companies are working at conditionally “removing” the black box in LLMs, which was never really a necessity, but just an implementation difficulty of tracking it.
I guess we all have to wait for someting like the Therac-25 drama before we stop using AI. Who are we going to blame when anyting goes terribly wrong, the human programmer or the AI?
https://en.wikipedia.org/wiki/Therac-25
Oddly enough the Therac-25 incident didn’t involve AI, just human stupidity.
Totally agree. If you know how to use it, it performs well. If you just lazily ask it to do a difficult task, it doesn’t. You need to direct it and use it like you would a piece of machinery. No, a backhoe can’t build a house for you autonomously, but that doesn’t mean you’re better off digging out the basement with your bare hands.
There is no stopping this trend, that’s were most code is heading soon, use these LLMs as tool yet don’t expect that it will automatically do everything for you, while this will happen eventually, they are not there yet.
The main advantage of using CoPilot or a LLM is that it saves time. Especially because it practically knows everything. Where I would had to read documentation of libraries or APIs for two hours, it just writes often functioning code. Even if I know the programming language and libraries used, it is just faster. I could not write hundreds lines of codes in seconds.
You can also debug with LLM, it can write tests, include debug outputs etc. and it is surprisingly good at using this to fix problems with the code.
Only thing where I’m really behind is when it tries to write something with security implications, like sever side code that takes user data. Better check everything twice then.
“I could not write hundreds lines of codes in seconds”
Sure you can. Every time you use an API, SDK, or library you’re doing exactly that.
“.. it practically knows everything.” Unfortunately within that everything are a lot of incorrect, inefficient, and broken things, and it ‘knows’ no difference between those and the rest. You may or may not know, but that depends on your own prior learning.
“Security .. Better check everything twice then.” If you have it writing code with security implications that you don’t know how to handle it doesn’t matter if you check it twice or a thousand times you’ve already lost.
You’ve already lost the security aspect. Essentially all code has potential security issues or exploitation points when written incorrectly.
AI coding assistants are a symbiotic technology meant to be combined with hordes of H1Bs and compensate for their general resume dishonesty and lack of talent
I am glad I am retiring within the next few years. I like to program and figure out things myself (but still use library APIs). I really feel letting AI do the ‘work’ is just going to dumb down our work force… ‘Let the AI do it!” . Sad really. We saw this with flying remote control planes. With GPS, auto stabilizing, fancy radios, etc., all of a sudden ‘anyone’ can fly a model drone or airplane. Great for marketing/sells. Sad as the ‘skill’ is no longer needed which then brings in that unwanted element that don’t follow the rules… Which trickled down to FAA adding more rules…. Which affects us.
“Unfortunately within that everything are a lot of incorrect, inefficient, and broken things, and it ‘knows’ no difference between those and the rest. You may or may not know, but that depends on your own prior learning.”
+100. Garbage in, garbage out… or half truths, or … This AI thing will make a great propaganda tool for the lemmings. Creators can tweak there models to have their users see things a certain way…. It’s crazy. Goes for coding too. There might be a better way to do something, but so what, the AI cranked out a solution (as that is what was programmed with as input data) … Just go with it… I can see that just from above comments… No real critical thinking… like what got us to the moon and back.
Microsoft sifting through open-source applications with exclusions against monetization may have broken laws.
It that were true, what about the hundreds of thousands if not millions of people who have applied techniques learned from open source code to their commercial projects?
Cult leaders a danger in open source software?
do cult leaders rely on volunteers?
AI Overview.
Yes, cult leaders often rely on volunteers to operate their groups
and further their agendas. Here’s why and how this reliance on
volunteers plays out in cult dynamics:
Free Labor:
Building Community and Commitment:
Indoctrination and Control:
Exploitation of Vulnerabilities:
Promoting Group Goals:
Funding and Operations:
It’s important to remember that not all volunteer organizations
are cults, and many groups rely on volunteers for positive contributions
to society. However, in cult contexts, volunteering can be a critical element
of manipulation, control, and exploitation.
I’ve been a developer for almost 30 years now and I agree partially with that point. It’s important to remember that it’s a tool and it should be used like one. I’ve had bugs that’s taken several days to figure out (complex embedded software, cloud backends, etc.), as we all have. I’ve been trying GitHub Copilot and I’m finding it to be a great tool. It creates great comments 90% of the time, I’ve had it figure out bugs in seconds, etc. and it’s been a very valuable tool. However, I can see where it can cripple a new programmer if they rely on it too. There’s been instance where it just could not flat out figure out the quest at hand, no matter how many different prompts I’ve tried. After some debugging I would be like, “that can’t be the issue because of x, y and z.” and it would simply say, “Oh yeah! Great catch, you’re absolutely right! Thanks for pointing that out. Here is what’s going on…” and then it would catch the mistake and fix it. Moral of the story, companies that rely on it with novice programmers may have more issues when the mud gets thick. It’s a tool, not a replacement… For now.
those agents are just enhanced databases, running queries with natural language instead sql. they don’t have zero shot problem solving capability yet.
Is there something I’m missing today? Seems this discussion has been heavily moderated.
I’m not ok with this.
Unfortunately for you, your not OKness has zero relevance to a commercial entity.
“discussion has been heavily moderated.”
Welcome to HaD.
In the last year I have had more posts removed than posted :(
(I’m sure this will be removed)
Is this alarming to noone? Two months are a lifetime in these matters.
Have any of you tried Claude Code?
I like vibe coding. Once enough companies rely enough on their cool vibed software, we have plenty of security holes to find and fix. Also once something more complex brakes they can choose between shutting down or asking us for help.
Either way we already plan to charge extra for fixing slob code 👍
Lots of comments from people that can’t prompt engineer their way out of a wet paper bag.
Funny how no one mentions the underlying foundational model they use, maybe they don’t actually use Copilot at all?
Prompt engineering and pair programming with Copilot has not only made me a 5x developer, but also a much better developer, just by using “Explain”.
A human’s job using AI is to understand it is wrong and correct it.
It is a partnership with a tool. If you don’t know more than the tool, that is on you
My coding partner?
Not AI, but that rubber ducky (or small pony plush) that I talk too and (fortunately) never replies, but makes me think out loud.
I often use AI for boilerplates tho.
Like when I make a new python script, it generates the boring part of argument “parsing”, generating the app class, and the basic GUI.
So I can only focus on the important code itself.