AI copilots are changing how coding is taught

I'm very impressed with the best models — but, because I remember how awful NLP used to be, "very impressed" still means I rate the best as being around the level of an intern/work placement student most of the time, and even at their best still only a junior.

It's great, if you're OK with that. I've used GPT-3.5 to make my own personal pay-as-you-go web interface for any LLM that's API-compatible with OpenAI despite not being a professional Web Developer.

It's fairly fragile because it's doing stupid things to get the "good enough" result.

Bu that's OK, because it's for me, I'm not selling it.

(As for the lesser models… I asked one for a single page web app version of Tetris; it started off lazy, then suddenly switched from writing a game in JavaScript into writing a machine learning script in python!)

If you ask me, they shouldn't have to, in the same way that you probably don't know how to diagnose a coax cable problem.

The major public clouds all have completely software-defined networks (SDNs), and concepts like subnets are basically emulated for the sake of legacy systems.

Why would we want subnets, like... at all? Why can't all systems just have an IP address and use point-to-point communications? That's literally what the underlying SDN does with the packets anyway! The subnets and routes you see don't map 1:1 to the underlying network. The packets are stuffed inside a VXLAN packet and routed between random hypervisors scattered randomly across multiple buildings. Just give up the pretence, give everything an system-assigned public-routable IPv6 address and be done with it. Better yet, auto-register everything in a private DNS zone and auto-generate internal use SSL certs too.

The amount of wiring we do manually is just insane, just so that Azure and Amazon can help greybeards pretend that they're operating a Cisco router and need to stand in line to file the paperwork required to get an SSL certificate.

He's had to completely rethink how they approach their industrial designs and build machines and transition to much more electronic based things with fewer moving parts, and build things they can just adjust with computers and point-and-click GUIs, because people just don't know how these old things work from a physical reality perspective. My dad was very distraught by the caliber of engineers he's seeing in the "next generation".

But that's not the only thing.

In Canada, our aging population of tradespeople are retiring in droves and we have a dearth of younger people to replace them. It's so bad, that in my province they've completely redesigned the Grade 11-12 highschool curriculum to have "fast track" paths into trades where 80% of their time is spent in coop/apprenticeship (good thing!). We have a housing crisis and we have nobody that actually knows how to build houses in our country while the federal government imports 1 million people per year with nowhere for them to live. Most kids these days just want to be "influencers".

Spelling and grammar in young people is absolutely atrocious because they are totally dependent on autocorrect; and they can't type using physical keyboards because they only ever used a touchscreen keyboard on phones and tablets.

It's not just programming being destroyed by copilots. It's an overall dumbing down of our entire civilization.

Everything else being exactly equal would I like someone I work with to know c over not? Sure.

But would I take a world with many fewer programmers that all knew c over the one we have today—definitely not. It would be a significantly poorer world.

I see the same arguments about higher level languages. All of the tech industry is about standing on the shoulders of giants. I do believe that lower level knowledge can help a great deal but using this argument I can say something like:

Kids these days don’t know basic assembly, they have no idea what an or/and/nor/xor gate is, they’ve never built a computer from components (no, not cpu/mb/ram/etc, I’m talking transistors and soldering).

Maybe LLMs are different but I don’t think they are, they are yet another tool that some people will abuse and some will use wisely. No different from an IDE or a higher-level language in my book.

I have next to zero idea how many things I use daily work (like my car for example), it doesn’t stop me from being able to drive where I need to go. I have configured lower level networking equipment in the past and I couldn’t be happier that I don’t have to do that drudgery anymore.

All I’m saying is this is a dangerous argument to make because someone can always one-up (one-down?) you. “Oh you had NAT? Luxury! In my day we didn’t even have a network, we had to….” (See also: Four Yorkshiremen [0])

[0] https://youtu.be/ue7wM0QC5LE?si=Mm-FY1oooq2XkCQz

As a Polish person, I don’t mind you changing the constitution, but for example with our national anthemn we are way more attached to changing how it sounds than Americans are to theirs. Ditto where our flag and our symbol can be used.

As for Bard - did you try arguing with it that constitution guarantees you the freedom to play with it? I managed to convince gpt to do some weird stuff by arguing for cultural sensitivity.

Jesus, they have coded pearl-clutching and finger-wagging lectures in my computers. You know, those machines that used to be brutally efficient at doing what you asked of them.

In a way, ChatGPT both replaces the need for junior developers and creates a situation where you'll end up with a developer shortage because not everyone can start right away as a mid-senior level.

The consequences are that developers can tackle basic tasks which are supported by the frameworks they use, but once something is not supported or straightforward they don’t know what to do and get completely stuck.

From society’s point of view, the usefulness and value of the task force decreases and important problems are not solved or aren’t efficiently solved.

Something like this was happening with coding bootcamps as well. Lots of people who can code what they were directly taught but don’t have the basics to go outside of that.

Tangent, but it used different fonts? I can’t imagine how this is possible given how LLMs work under the hood (sampling likely tokens which represent Unicode character sequences - it doesn’t operate on rich text so afaik has no way of seeing or changing font information). Is there something weird happing with the frontend breaking the code/not-code formatting they do (as a cosmetic thing rendering the output)?

Well, they can, but the "no filter" option does not necessarily generate satisfactory results either. I find it hard to blame Google for not wanting to put their brand on an AI providing a ranking list of races by intelligence or whatever kind of offensive thing people are going to try to make it produce.

That’s CTO level coding right there, gotta tell bard about my great app idea.

I recently learned Swift & Metal this way - knowing Python and other languages, I kept pasting my pseudo-code, asking GPT to convert it into Metal/Swift, and then iterating on that. Took me a week or two to get the language without reaching for any sort of manual/tutorial. Speaking from experience - it would take me 2-4x as much time to learn the same thing otherwise.

If GPT was any better, I'd have no need to fix the code, and I wouldn't learn as much.

It's also not nearly mature enough for learning it be a good ROI in a degree program. Community college or adult education class? Maybe. Bootcamp track? Sure, I guess. Novelty elective for a few easy credits and some fun? Totally.

But if I'm a student in the midst of a prolonged, expensive program spanning years, learning how to coax results out of today's new generative AI tooling is not preparing me very well at all for what I can expect when I try to enter the workforce 2 or 4 or 8 more years. The tools and the ways to interface them, "Prompt Engineering" or whatever else it's called will inevitably evolve dramatically between now and then. So why am I learning it while I'm still deep in my academic bubbles? And what are prospective employers getting from a degree that focused heavily on some now-defunct and dated techniques? My degree is supposed to mean that I've learned foundational material and am ready to be productive on something, but what that mean when too much of what I've learned is outdated?

I have worked exclusively with React/Next, Node, and Mongo for years until I took over a legacy code base in October.

I had to teach myself Python/Flask, Vue, and Laravel without any kind of documentation or guidance from the previous developers or anyone else in my company.

AI has been able to help me get a bit further down the road each time I run into an issue. But AI hasn't been able to hand me perfect solutions for any of my problems. It helps me better understand the existing code base, but thus far none of the answer provided have been 100% accurate.

If anything, it's like cooking with kids, not like going to McDonalds. I'd give extra points if they can solve the task with LLM in time. The hardest parts in programming is finding subtle bugs and reviewing code written by others - two tasks that LLMs can't help us with.

If they can easily solve the tasks with LLMs then it is a legitimate question to ask if you should be teaching that skill. Only common ones can be solved that way though. Why don't you give them a bugged code to fix, that way LLM inspiration is not going to work, if you check first to make sure LLMs can't fix the bug?

Perhaps the lesson is about how to read and evaluate code and how to test code. If students get good at how and when to spot errors and how to construct test scenarios that ensure the code is doing what it should then perhaps that will lead to even higher quality code than if they were learning, producing bugs, and then learning how to evaluate the code and test what they had written.

You can only learn to play the guitar by picking it up and spending a lot of time mucking about with it. There's a bit more to it, but this is really the core: you need to play and get that muscle memory and "feeling" for it. You need to "rewire your brain".

Coding, or any other skill for that matter, is no different. The only way to learn to code is to actually write code. Even if you fully understand anything ChatGPT gives you (which most students probably don't), that's no substitute for actually writing the code yourself.

I don't see how it's not hugely harmful for the development of students and junior programmers to use AI. Even if these tools were perfect (which they're not), you need to develop these basic skills of learning to read the code. You need to make mistakes and end up with crummy unmaintainable code, and realize what you did wrong. Etc. etc.

Even for senior programmers I'm not so convinced AI tools are actually all that beneficial in the long run.

Only when AI systems will be able to fully understand entire systems and full context and can completely replace human programmers will that change. I'd estimate that's at least 50 years off, if not (significantly) longer. Anything before that: you need someone who fully understands the code and context, in depth.

I wonder if a more AI-resistant approach is to provide poor code examples and to ask students to improve it and specifically explain their motivations.

They can’t just rely on code output from an LLM. They need to understand what flaws exist and connect the flaw to the fix, which requires (for now, I think) higher-level comprehension.

I found that having a solid foundation was critical for knowing if something would work, and even just to write a prompt that was semi-decent.

At one point I asked for what I wanted, but it kept only doing half of it and I could tell just by glancing at the code it was wrong. I then had to get very, very specific about what I wanted. It eventually gave a correct answer, but it was the long annoying option I was trying to avoid, so it didn’t change my end result, and I don’t even think it saved me any typing due to all the prompts to get there. It just gave me some level of confirmation that there wasn’t an obvious better way that I’d be able to find quickly.

To me, exams are taken in halls, written on paper, proctored, under deadline. Points may be deducted for syntax mistakes or unclarity as the examiner wishes.

Separately, home work is graded in ways that already makes cheating pointless; usually for 1) ambition/difficulty in the chosen problem 2) clarity in presentation and proofs, argued in person to TAs.

LLM should have no bearing on any part of education (CS or otherwise) unless the school was already a mess.

I hear what you are saying but where does it end? Is Hello Fresh cooking? Is going to grocery store cooking or do you need to buy it direct from a farmer? Do you need to grow the food yourself?

Is renting a car “driving”? Is leasing a car “driving”? If you can’t fix a car and understand how it works are you really driving?

Yes, most of those questions are ridiculous but they sound the same to me as some complaints about using LLMs. Those complaints sound very similar to backlash against higher-level languages.

Python? You’re not a real developer unless you use C. C? You’re not a real developer unless you use assembly. Assembly? Must be nice, unless you’re writing 0’s and 1’s you can’t call yourself a developer. 0’s and 1’s? Let me get out my soldering gun and show you what it takes to be a real developer….

If I were a teacher, I would have asked the popular bullshit generators to generate solutions for the test questions, and if a student’s solutions were very similar, I’d have them do some 1:1 live-coding to prove their innocence.

This is why I think that the old way of having tutorials instead of tests is vastly superior. When you are in a tutorial group (typically five or fewer students) and your tutor asks you to explain something to the other members of the group you can't hide behind an AI, a textbook, or even your own notes. Your lack of preparedness and understanding is made abundantly clear.

People have been committing terrible code to projects for decades now, long before AI.

The solution is a code review process that works, and accountability if experienced employees are approving commits without properly reviewing them.

AI shouldn't have anything to do with it. Bad code shouldn't be passing review period, no matter if it was AI-assisted or not. And if your org doesn't do code review, then that's the actual problem.

You just need to ask it what to ask. /s

Isnt this what code reviews are for? I catch a decent amount of code that looks AI generated. Typically, some very foreign pattern or syntax that this engineers never used nor is common in the codebase. Or something weirdly obtuse that could be refactored and shows a lack of understanding.

Normally I ask something like, "Interesting approach! Is there a reason to do it this way over (mention a similar pattern in our codebase)?" or if it's egregious, I might ask, "Can you explain this to me?".

This feel similar to early career engineers copy pasting stack overflow code. Now its just faster and easier for them to do. It's still fairly easy to spot though.

This is a widespread problem regardless of AI. Hence the myriad Stack Overflow users who are frustrated after asking insane questions and getting pushback, who then dig their heels in after being told the entire approach they’re using to solve a problem is bonkers and they’re going to run into endless problems continuing down the path their on.

Not that people aren’t on too fine a hair trigger for that kind of response. But the sensitivity of that reaction is a learned defense mechanism for the sheer volume of it.

Having an oracle that knows how to put a framework of events together (even wit errors) is much better than asking a human to do it from scratch.

When I asked him what prompted him to do that, he said copilot suggest it so I just followed. I wonder if you could hijack copilot's results and inject malicious code as many end users does not understand lot of the niche code it generates sometimes, you could manipulate them to add the malicious code to the org's codebase.

A significant problem is the subconscious defense mechanism or bias that compels us to conclude that AI has various shortcomings, asserting the ongoing need for status quo.

The capabilities of GPT-3.x in early 2023 pale in comparison to today's AI, and it will continue to evolve and improve.

That is a great point. The issue of not asking the right questions has been around as far as I can remember but I guess it wasn't seen as the bottleneck because people were so focused on solving problems by any means possible that they never had to think about solving problems in a simple way. We're still very far from that though and in some ways we have taken steps back. I hope AI will help to shift human focus towards code architecture because that's something that has been severely neglected. Most complex projects I've seen are severely over-engineered... They are complex but they should not have grown to hundreds of thousands of lines of code; had people asked the right questions, focused on the right problems and chosen the right trade-offs, they would have been under 10K lines and way more efficient, interoperable and reliable.

I should note though, that my experience with coding with AI is that it often makes mistakes for complex algorithms, or it implements them in an inefficient way and I almost always have to change them. I get a lot of benefit from asking questions about APIs and to verify my assumptions or if I need a suggestion about possible approaches to do something.

Honestly I find this to be the biggest advantage to using a coding LLM. It's like a more interactive debugging duck. By the time I've described my problem in sufficient detail for the LLM to generate a useful answer, I've solved it.

In my code reviews the person who wrote the code needs to explain to me what they changed and why. If they can’t then we are going to have a problem. If you don’t understand the code that an LLM spits out you don’t use it, it’s that simple. If you use it and can’t explain it, well… we are going to have to have some discussions and if it keeps happening you’re going to need to find other employment.

The exact same thing has been happening for pretty much the entire time we’ve had internet. Stack Overflow being the primary example now but there were plenty of other resources before SO. People have always been able to copy/paste code they don’t understand and shove it into a codebase. LLMs make that easier, no doubt, but the core issue has always been there and we, as an industry, have had decades to come up with defenses to this. Code review being the best tool in our toolbox IMHO.

But that's not what these LLM systems are. https://hachyderm.io/@inthehands/112006855076082650

> You might be surprised to learn that I actually think LLMs have the potential to be not only fun but genuinely useful. “Show me some bullshit that would be typical in this context” can be a genuinely helpful question to have answered, in code and in natural language — for brainstorming, for seeing common conventions in an unfamiliar context, for having something crappy to react to.

> Alas, that does not remotely resemble how people are pitching this technology.

It is exactly what happened to you: it wrote bullshit. Plausible bullshit but bullshit nonetheless.

This sentence summarizes the issue with the current AI debacle, along with the whole "just copy/pase code from stackoverflow and earn top bucks" meme that was going around in 2010s.

You're not gonna be a valuable dev if you're just write wrong code faster. Not only does chatgpt/copilot give haphazard code half of the time, it approaches seemingly random syntax and format. Even if LLMs are polished, you're gonna need stand software engineering knowledge to know what's right and wrong.

(Last night I ended up writing that kind of code because GPT-4 didn't quite get it right for me, but 90% of my code like that has been LLM-created in the past 6 months and I look forward to that creeping closer to 100%)

What's are the XML and JSON being used for?

If you're working for a company, you almost certainly aren't working for the "XML to JSON, library salesperson" company, you're probably connecting different API endpoints. What do those endpoints do? Do they do ethical things?

I once interviewed and was asked what is the difference between thread and a task. I provided a 'dumb' correct answer because I did not remember the text book definition, as I have been out of school for several years. The interviewer ignored everything I've said and told me "Actually, it's <insert textbook defintion>".

It almost seems that computer science teaches you too much of the theory and not enough of "get shit done".

I really enjoyed computer science and graduated with honors, but writing business code is kind of meh and boring. I know people who dropped out of CS due to having a hard time with algorithms and more advanced courses. I feel like they should have stayed and would do fine doing boring work. However, nobody tells you this, there seems to be a lot of gatekeeping in tech.

Having worked with both kinds - I'll take a dev with experience in algorithms and no knowledge of a framework we need to use over an opposite. Especially in times of GPT, where gpt will allow you to switch to a new framework in no time, but struggle with anything besides the boilerplate code structure.

The programmers who are mostly only capable of doing this kind of grudge work will lose their jobs and need to transition and adapt to a new form of grudge work.

And yes, as you point out, that's a lot if not most of them.

The point of learning Dijkstra’s algorithm isn’t to be able to reproduce it, the point is that you know what’s available to you to solve a problem and what areas of the algorithm you can tweak for your use case.

If you don’t have a good mental model of how the code works and how you write a maintainable solution then you’re not able to analyze the tradeoffs of the high level competing requirements like AppSec vs UX vs Maintenance vs Engineering Effort that is at the heart of what a software engineer does.

And this doesn’t change with AI either, the code that comes out of LLMs is often poorly designed but you can’t tell that unless you have worked on different types of systems to know why we might use immutable data here but shared memory in this situation.

I was writing a Wordpress plugin and by default in PHP all function definitions are global, e.g. is_single that WP defines is global. Naturally to avoid conflicts you would use a namespace, but since most of the examples I saw used prefixed function names, I decided to try that as well.

In my opinion, coding just feels much clearer when you prefix all your names, like my_library_my_func. When I see my_library_, I just immediately know that is my code. If you use different prefixes for different modules, you can tell from a glance which modules a piece of code interacts with. In C++, you can tell a random word is a field by the simple fact everyone prefixes them with m_. I've seen people using prefixes for pointers as well.

This is the same concept you have when designing an UI. Everyone agrees a problem with hamburger menus is that you don't know what's inside the burger until you click on it. If you want people to be aware something exists, you need to make it appear on screen, explicitly.

Instead, languages have evolved toward the very opposite. We ran away from self-documentating variable names and prefixes, and toward namespaces, "const" and other keywords, and "OOP" that feels less object-orientated and more press-the-dot-key-to-get-a-list-of-methods orientated. We depend on docstrings that show in the IDE, and then on auto-generated documentation from those docstrings. Typescript is probably the worst case of this, because it gives you a lot of tools to make the dot work the way you want, you'll spend way too much tinkering with the dot instead of just writing code that actually runs.

Thanks to this, when you look at code, you have to wait until your language server figures out what you're looking at for you. If the IDE doesn't work, it's effectively impossible to code anything in many cases. But the variable names are shorter so people think it's cleaner and better, like removing features from an UI to make it cleaner.

100% - this was not obvious to me until I was working at a startup and delegated a task to some others. They tried for close to an hour to find a solution to a problem and came up empty handed. I had a go and instantly found the answer.

What was the difference? It was our ability to put into Google the right terms to find the answer.

Already I find myself doing most coding via AI, with my work being high level skills (choosing how to organise code, knowing when to refactor and when the AI has gone too far).

The productivity increase is crazy.

The future quite likely will look like the minority report interface.

With LLMs, statistics play a much more important role so you're really not in the same realm anymore. It's like going from digital to analog, things work differently at a core level.

I get by, but I often feel a bit handicapped vs my peers. Like building a house on a shaky foundation.

For example, let’s say you wanted to write code in a language you did not know. Then these simple tasks can be accelerated because you’re not blocked by syntax errors.

But... a significant amount of code is simple. Even in complex projects there's still a lot of trivial code.

And even when they produce something wrong, it's usually still faster than starting from scratch. At least for smallish bits of code. Though admittedly it can be a bit more frustrating on occasion because you're doing something more like code review and who doesn't hate code review?

01001001 00100000 01100001 01101101 00100000 01101110 01101111 01110111 00100000 01110110 01100101 01110010 01111001 00100000 01110011 01110100 01110010 01101111 01101110 01100111 00001010

The need to work with other people?

Or the need to explain your work?

Both of those are important skills in professional programming?

But, I've used it to review, debug, document, test, and explain code. I occasionally use it to stub out a solution but usually it then requires manual tuning. Any modestly complex algorithmic stuff it usually makes lots of mistakes. But it is able to spot uncovered edge cases, or suggest ways to test algorithms.

I think more of it as an artificial pair programmer pointing out my mistakes, and helping me be more productive. It's also good at figuring out syntax issues. Often when dealing with languages I'm less proficient in the main battle is simply figuring out how to do X in a language. If you are trying to learn things like Rust (which is hard to learn), AI is your best friend. Because it can explain you your code, your mistakes, and suggest alternate ways of doing things. All you need to do is ask. Remembering to do that is the hard part.

One feature I think could be useful is to ask it to correct very basic errors in a section of code, but this need to be well-integrated in the editor to be worth it. This could also be automatic (the detection) - like an slightly more intelligent jetbrains inspection.

I've also tried some "whole program" synthesis with mixed results. It usually can get something up and running, but almost every time it has had subtle bugs in it - fixing these (with or without the AI) often got me close or higher to what it would have taken me to do it from scratch.

The advantage(?) is I might never have bothered beginning from scratch - getting the first rough draft get you immediately into iteration mode.

As an example - I asked GPT-4 to write a python program reading in a json file conforming to a jsonchema[1] and transforming this into a GPX file.

It ended up generating code trying to get `properties` keys from the json *file*. So it clearly did not understand the schema. Maybe jsonschema is to obscure?

[1] (I provided the schema and a link to the schema standard (though I'm not sure it actually read the link))

If it gets it wrong I just keep typing until it guesses the rest or I finish writing the comment.

There's no difference here in my mind between cheating and the models. If someone holds your hand for all your homework in school, you're not going to learn, whether that's a person or a language model.

So if AI advances in 4 years to the point where we're all deprecated, then fine, a student learning it got lucky. But otherwise, you're setting yourself up for failure if you lean too heavily on LLMs.

I don’t think many would describe Yann Lecun as threatened by these tools, here’s his take on the LLM approach: https://youtu.be/MiqLoAZFRSE?si=415gg2vhjz2Sd84s

I think you're projecting a little bit.

You're not skilled or experienced enough in the field to understand that programming sometimes goes beyond simply gluing together snippets of simple, generalized code until you have something that sorta works, and thus believe AI to be more than capable of replacing you, and you don't understand why other, more experienced people don't feel the same way.

Also I do use algorithms every day.

I am, however, extremely concerned as a user, because the senior management in many places will push for them anyway, with the resulting drop in software quality across the board.

"Students don't need to learn grammar and syntax and really any vocabulary. AI assistance lets them understand higher level German concepts without needing to know how to conjugate for gender and number or remember if a noun uses der, die, or das."

You see a lot of examples of things that seem absurd when applied to non-technical topics, but as soon as you apply them to computers all skepticism goes out the window. If I told you I have a person who speaks perfect English but frequently lies and outright makes things up, you'd say that's a politician and not to be trusted. But if I say I have a computer with those same properties, suddenly it's the most amazing thing in the world, and we should implicitly trust it to make our decisions and educate our children.

I mean, at the end of the day I am not a coder, therefore any code I debug I'm probably not good enough to write, yet I've found numerous bugs in both open source and proprietary code with suggestions on how to fix it.

We already have this problem, even without the LLM-generated code. I see younger developers pull out all sorts of tiny libraries because a) they think it will save them time, b) they are insecure about the correctness of their code, and c) they often have no idea where to start when problems start to happen (solving problem is usually writing a github ticket or blindly trying another library).

I think LLMs will exacerbate the problem. These days I rarely see engineering spirit in figuring out how things work, willing to understand deeply OS or compiler internals, or even trying some crazy ideas, like "let's write a JIT to speed up our DSL".

With an LLM it is possible to write code that's too "clever", thus you won't be able to debug it. And in many cases neither can the LLM.

Seems to be a reason behind a lot of things wrong with school right now.

...a kid was tasked with researching Peru "in the news." After 10 minutes I went to check on them and they had nothing done. They told me there was nothing about Peru in the news and showed me their Google search results. They had googled "in the news" only. They didn't include the word Peru in their search. Not only did they not use the technology correctly but they didn't ask for help or say anything after their one attempt to get information failed. They just sat there.

source: https://ol.reddit.com/r/Teachers/comments/1axhne2/the_public...

Interesting. How is the book in audio format?

As a "must read" book that no one actually reads, that may take the edge off.

Is it? When you take procedural, object-oriented, logic, and functional programming, they did not only changes how we code, they also change how we think about the solution. We had new entities and we could describe the relations between them to describe an algorithm. Natural languages have been there forever, but the thing it lacks is formality. Every term describe a very large class of objects and specifying which one you're referring too is arduous. The kind of specification needed to describe problem solving steps is what created programming languages in the first place.

Programming languages are not some arcane art that we need to suffer through. They're the best way to specify to a machine how it should work to do a task. Maybe AI can be the new machine, but its capabilities so far are not that impactful IMO.

No, LLM is not a paradigm for programming, but it might be a new paradigm for autocomplete, refactoring, translating, and so on.

Maybe an introductory search in other fields is what required? Or heading to the library? Even in software engineering, we see people reinventing the wheel because they can't be bothered to read a computer science book.

On the other hand, it seems to be something LLMs are particularly bad at. There are many similar but subtly different concepts. People use the same words for different concepts and different words for the same concepts. Every paper invents new terminology. And there is often very little written material available.

LLM programming removes the need to write tedious code, which means the author has fewer opportunities to ask themselves if there are easier ways to model the problem they're solving. We would never have gotten language features like Objects, Iterators, first-class functions, and exceptions if all of the boilerplate to emulate those features could be autogenerated so easily.

Going forward, there will be less impetus for programmers to pick better languages and abstractions for their work, since the boilerplate cost of picking the wrong one is subsidized by the llm.

So I think the issue isn't so much that people won't know the syntax rules and bizzare-semantics trivia, but that people won't realize that the syntax rules could be different and that the whole point is for them to make your life easier.

Programming IS syntax.

If you want higher-level /skills/ you need foundational skills.

If you want higher-level understanding, well that’s what pop sci is for.