Just ask it to rewrite the shitty code you wrote in a language you barely understand to “follow standard best practices in <language>” or something like that and it will add advanced typing features, functional programming for iterables, advanced exception handling, proper concurrency handling, optimize control flows, use better equivalent functions, etc.
As long as you understand the foundations of these concepts in at least one language anybody can become pretty close to an expert in most languages instantly. Especially since most of them are C based and pretty similar
The output will sometimes change the logic but I mean that’s pretty easy to catch and fix
Rip C++ nerds that memorize the entirety of each releases manual to shave off 3ms in every single function
you’re probably onto something but I feel like this isn’t gonna stop employers from requiring people to have x years experience with whatever specific stack they’re using
The output will sometimes change the logic but I mean that’s pretty easy to catch and fix
Lol. Lmao.
me writing spaghetti code
AI writing spaghetti codehand pulled vs. mechanically extruded pasta
Writing code was never really the hard part of programming
It never was but it inevitably took up a lot of your time anyways to learn the language and various frameworks
In the hands of a skilled craftsmen, the machine enhances the productive process of the craftsmen. In their shop, as part of their labor process, making bespoke things, the machine serves the craftsmen.
However, the machine also reduces the socially necessary labor time for the mass production of a given thing. The laborers within this production environment are not craftsmen. All they know is how to operate the machine. Making parts of an eventual whole they’ll never have a full hand in producing.
As the laborers are replaced and the machine persists, there is less demand for the kills of a craftsmen, and the new laborers do not need to be trained at the same capacity as the craftsmen. This process naturally deskills the labor force as time progresses.
You find it useful because you are trained and can more effectively describe the issue its resolving because the code is the result of your skill and training. You are the craftsmen in this situation. Soon however, you will become the supervisor to juniors who have even less of any understanding then you had in their position. Producing code using a machine, with little understanding of it’s output, leaving you to pick up the slack.
What I really need is a steaming pile of new legacy code that might even work.
Llms are the affordable table saw, no, the affordable router table of the software world.
They’re a powerful tool, but they increase the chance that the user will fiddlefuck around doing something stupid at best or something brutally, nastily, scared straight in the classroom dangerous at worst.
If there ever was a time to “jack off” and get rid of any computer interaction in your life, now is it.
This is only really useful in low expressiveness languages where there is not a huge set of language enhancements possible through libraries. Think Java exception handling for example.
In essence it works if you “best practices” are things like don’t use switch statements.
It doesn’t work if you best practices are things like use
Result<T, E>from this functional result library.Essentially LLMs don’t really work “at scale” if you need anything more complicated than what the average internet tutorial code is in your language.
Same with perf.
Also this only works 60% of all the time though if that, so the more requirements you pile on the less likely it will hit all of them properly.
In my experience, LLMs can often pump out perfectly fine starting code for very basic problems. If you’re coding up some tiny blog it’ll probably be good enough that someone with some coding experience can unfuck the places where it screwed up.
That’s not what professional software engineering
is about though. You want a codebase built in a coherent, consistent, repeatable way that can be independently worked on by dozens of people often at the same time, and LLMs cannot do that in any real capacity. It might serve as a decent tool for spinning up quick proof-of-concepts (I’ve poked it to figure out a new framework before, mostly due to terrible documentation making it difficult to figure out how to use specific features) but none of it was production-worthy and never would be.Furthermore, if you’re using it to figure out entire languages/frameworks for you, you’re quickly finding yourself in a position where you don’t see where it’s fucking up, which is going to hit you down the line when you’re playing whack-a-mole with a bug or severe performance issue in a giant codebase.
I still think you are talking about an architect and principal engineering level - which AI is not going to replace for a long while. It’s a productivity multiplier and maybe will replace junior developers at most. But that still seems another year or so away if not longer
I’m not advocating for using it to attempt and write a new feature end to end. Use it to help with your code function by function
It’s great for syntax, not good for the where
It won’t kill off the need for skill, but a lot of lazy “coders” will stop even learning a minimal amount, and get by on no skill at all. Until they get fired, too.
Nothing the LLM generates can be relied on, it’s a gibberish machine.
agree with OP but its more than a gibberish machine for most modern implementations. copilot agent mode is good
You dont need an LLM to do this though. I thought this skill just comes naturally to programmers who have had a lot of experience in diverse areas.
I’m in Linux/OSS spaces and virtually no one uses an LLM here since much of the work is more social than technical (negotiating many ways to resolve an issue) with a lot more problem solving than busywork. At some point you have to get your hands dirty and there are no more shortcuts.
In fact, LLMs have only harmed us in that there are more bogus bug reports and garbage slop being tossed at projects not to mention every community git forge having to implement some form of ddos mitigation because of the very harmful and real negative externalities of LLMs.
It’s also literally just an auto-format/quick-fix feature in nearly every IDE, and was long before the AI craze.
Ofc I don’t NEED it but it saves me a ton of time
At work this means less risk of being fired for low performance
At home this means more time for chores and other interests
Those issues you mentioned are due to the users not understanding the limitations of LLMs and what they’re good or bad. It’s a tool that requires skill and knowledge to use well and unfortunately a lot of people treat it like it has understanding and reasoning like a human
At work this means less risk of being fired for low performance
It sounds like you need a union more than you need an LLM.
At home this means more time for chores and other interests
With hobby coding, the journey usually matters more than the destination.
With hobby coding, the journey usually matters more than the destination.
Not always. There are some projects I do for learning, some projects I do to improve my life
It sounds like you need a union more than you need an LLM.
I know but my average coworker has always been multi millionaires with property and half of them are Indian fascists, one quarter Chinese anti- communists, and almost all constantly fearmongering about the homeless in SF
Become “pretty close to an expert” by… outsourcing the process of improving your code to a machine…
Even if it improves your code in that scenario, you’re not going to really understand what it’s doing or why. You can use AI as a shortcut for scripting, but you can’t use it as a shortcut for learning
Edit: Besides, we already have perfectly good static analysis tools. Just use a linter. Trying to use AI as a linter will just be worse and unpredictable compared to using an actual linter
But I’m not using it for learning. I already understand exception handling, concurrency, typing, etc.
But I only know the exact syntax for some languages
Now I can replicate the best practices for those concepts in a language I’ve never touched, and I can understand what it does because I know the equivalent syntax in another language and so I can also judge the quality as well
It’s even more confident when the new language is C based because I’m already familiar with other C based languages
Obviously it’ll never be as good as a person who spent time to learn the language by reading documentation and practicing but most cases it should be fine
I already understand exception handling, concurrency, typing, etc.
But I only know the exact syntax for some languages
Now I can replicate the best practices for those concepts in a language I’ve never touched, and I can understand what it does because I know the equivalent syntax in another language and so I can also judge the quality as well
I’m sorry but this just doesn’t match my experience. I have used greenlet, Node.js, asyncio, POSIX threads, kqueue, and uv and just recently I had to look at something that uses tokio (Rust) and I would never say confidently that just because I know the syntax of one concurrency library, that looking at a different language and equivalent library I can immediately judge the quality and understand what it does.
That is just not realistic
Don’t you know that all programming languages are the same, except each uses a different set of symbols and keywords? Since all languages are the same, we can use an LLM to efficiently translate code from one language into another where it will perform optimally. /s
“Computer, replace all the whitespace indentation with curly braces and put a semicolon at the end of every line, in order to convert my Python program to Rust”
In case my edit didn’t land in time: what makes the AI approach better than using existing non-AI static analysis tools
Well my personal experiences have just been that the ML approach catches a lot of things the static analysis tool hasn’t. Those are hard coded by humans and there are dozens of not hundreds of ways to write any given function with identical logic. It’s impossible for static analysis to be comprehensive enough to catch and fix a code block more than a few lines
E.g. I had a super ugly nested try catch exception block for this new integration test I was writing. It was using a test framework and language I’ve never used before, and so it was the only way I knew to write this logic. I asked the LLM to improve it and it broke up the nested try catch logic into 2 top level pieces with timeout functions and assertion checks I didn’t know existed. The timeout removing the need to throw an exception and the assertion fixing the issue of catching it
I’m glad you’ve gotten some actual use out of the LLMs! My outlook is more skeptical because I’ve seen too many interns get stuck on projects because they tried to ask LLMs for advice (which they did not double check) instead of reaching out to an experienced dev. The word calculators can only do so much.
Oh don’t get me wrong, I definitely think LLMs are gonna absolutely destroy kids ability to learn anything, including coding if they use it like a teacher
But for those who use it as a tool to build and do instead of learning, I’m quickly starting to become a strong believer in its usefulness
We’re cooked, open the schools, I can’t, etc.
I never memorized it, I just asked smarter nerds. And we shave off nanoseconds this isn’t your entry level course no don’t replace me with the machine I’m useful I’m not a worker
You can write FORTRAN in any language.
