[simonw]

The reason you can use these tools so effectively across native, mobile, Go, React etc is that you can apply most of what you learned about software development as a Python engineer in these new areas.

The thing LLMs replace is the need for understanding all of the trivia required for each platform.

I don't know how to write a for loop in Go (without looking it up), but I can write useful Go code now without spinning back up on Go first.

I still need to conceptually understand for loops, and what Go is, and structured programming, and compilers, and build and test scripts, and all kinds of other base level skills that people without an existing background in programming are completely missing.

I see LLMs as an amplifier and accelerant. I've accumulated a huge amount of fuzzy knowledge across my career - with an LLM I can now apply that fuzzy knowledge to concrete problems in a huge array of languages and platforms.

Previously I would stay in my lane: I was fluent in Python, JavaScript and SQL so I used those to solve every problem because I didn't want to take the time to spin up on the trivia for a new language or platform.

Now? I'll happily use things like Go and Bash and AppleScript and jq and ffmpeg and I'm considering picking up a Swift project.

[snoman]

This is difficult to express because I too have enjoyed using an LLM lately and have felt a productivity increase, but I think there is a false sense of security being expressed in your writing and it underlies one of the primary risks I see with LLMs for programming.

With minor exceptions, moving from one language to another isn’t a matter of simple syntax, trivia, or swapping standard libraries. Certainly, expert beginners do espouse that all the time, but languages often have fundamental concepts that they’re built that and need to be understood in order to be effective with them. For example: have you ever seen a team move from Java to Scala, js to Java, or C# to Python - all of which I’ve seen - where the developers didn’t try to understand language they were moving to? Non-fail, they tried to force the concepts that were important to their prior language, onto the new one, to abysmal results.

If you’re writing trivial scripts, or one-off utils, it probably doesn’t build up enough to matter, and feels great, but you don’t know what you don’t know, and you don’t know what to look for. Offloading the understanding of the concepts that are important for a language to an LLM is a recipe for a bad time.

[simonw]

> but languages often have fundamental concepts that they’re built that and need to be understood in order to be effective with them

I completely agree. That's another reason I don't feel threatened by non-programmers using LLMs: to actually write useful Go code you need to figure out goroutines, for React you need to understand the state model and hooks, for AppleScript you need to understand how apps expose their features, etc etc etc.

All of these are things you need to figure out, and I would argue they are conceptually more complex than for loops etc.

But... don't need to memorize the details. I find understanding concepts like goroutines to be a very different mental activity to memorizing the syntax for a Go for loop.

I can come back to some Go code a year later and remind myself how goroutines work very quickly, because I'm an experienced software engineer with a wealth of related knowledge about concurrency primitives to help me out.

[danw1979]

What are your thoughts on humans learning from LLM output ?

I’ve been encouraging the new developers I work with to ensure they read the docs and learn the language to ensure the LLM doesn’t become a crutch, but rather a bicycle.

But it occurred to me recently that I probably learned most of what I know from examples of code written by others.

I’m certain my less experienced colleagues are doing the same, but from Claude rather than Stack Overflow…

[skydhash]

Not Simon, but here is my take.

Code are practical realizations of concepts that exists outside of code. Let's take concurrency as an example. It's something that is common across many domains where 2 (or more) independent actors suddenly need to share a single resource that can't be used by both at the same time. In many cases, it can be resolved (or not) in an ad-hoc manner. And sometimes there's a basic agreement that takes place.

But for computers, you need the solution to be precise, eliminating all error cases. So we go one to define primitives and how these interacts with each other and the sequence of the actions. These are still not code. Once we are precise enough, we translate it to code.

So if you're learning from code, you are tracing back to the original concept. And we can do so because we are good at grasping patterns.

But generated code are often a factor of several patterns at once, and some are not even relevant. Just that in the training phases, the algorithm detected similarity (and we know things can be similar but are actually very different).

So I'm wary of learning from LLMs, because it's a land of mirages.

[ivm]

I've been programming since 2009 and lately I've been also learning a ton from LLM output. When they review my code or architecture ideas, they sometimes suggest approaches I outright didn't know because my day-to-day "rut" has been different so far.

LLMs are like a map of everything, even it's a medieval map with distorted country sizes and dragons in every sea. Still, it can be used to get a general idea of where to go.

[simonw]

I think an important skill to develop as a software developer (or any other profession) is learning to learn effectively.

In software these days that means learning from many different sources: documentation and tutorials and LLM-generated examples and YouTube talks and conference sessions and pairing with coworkers and more.

Sticking to a single source will greatly reduce the effectiveness of how you learn your craft. New developers need to understand that.

[skydhash]

> But... don't need to memorize the details. I find understanding concepts like goroutines to be a very different mental activity to memorizing the syntax for a Go for loop.

That's one of the argument that seems to never make any sense to me. Were people actually memorizing all these stuff and are now happy that they don't have too? Because that's what books, manuals, references, documentations, wiki,... are here for.

I do agree with you both that you need to understand concepts. But by the time I need to write code, I already have a good understanding of what the solution is like and unless I'm creating the scaffolding of the project, I rarely needs to write more than ten lines at time. If I need to write more, that's when I reach for generators, snippets, code examples from the docs, or switch to a DSL.

Also by the time I need to code, I need factual information, not generated examples which can be wrong.

[simonw]

Yes, I was memorizing the stuff.

The reason I used to stick to just a very small set of languages that I knew inside out is that because I was using them on a daily basis I was extremely productive at writing code in them.

Why write code in Go where I have to stop and look things up every few minutes when I could instead of use Python where I have to look things up about once an hour?

LLMs have fixed that for me.

> Also by the time I need to code, I need factual information, not generated examples which can be wrong.

If those generated examples are wrong I find out about 30 seconds later when I run the code: https://simonwillison.net/2025/Mar/2/hallucinations-in-code/

[skydhash]

> Why write code in Go where I have to stop and look things up every few minutes when I could instead of use Python where I have to look things up about once an hour

My workflow is different. Whenever I can't remember something, I look it up. And for something that I'm not familiar with, that usually means a lot of browser tabs. But I try to retrieve it from my memory first (and it usually exists in my short-term memory). And after some days, it has become part of my long-term memory and I don't need to look it up again. If I don't touch the language and its ecosystem for a while, I forgot some details, but they are refreshed with a quick read.

> If those generated examples are wrong I find out about 30 seconds later when I run the code

I would be grateful if those were the only kind of wrong I encounter. Writing code that does the stuff is usually easy. The difficult part is to ensure that the data fits the definition of correct at every stage of the process. And there's not some corrupting action somewhere. Doing so exhaustively is formal verification and it is costly (mostly in terms of time). So what you do is other kind of testing which only covers the most likely places and dimensions where thing can go wrong.

The stressful part is when you have to change some part to fit a new use case. You then have to carefully revise both the change and the other parts so that their definition of correct is consistent. And sometimes there's some decoupling mechanism which makes the link non-obvious.

That's the definition of wrong that I'm fearful of. Where two part are internally correct, but their integration is not consistent.

[ivm]

Yes, for example that's why https://learnxinyminutes.com/ exists. Like, I don't remember the particulars of JavaScript syntax or the core library after a year of not touching it, so before I had to reconstruct it in my head even for small tasks. Now LLMs solve this issue.

[pyman]

I agree Simon. With the little time I have these days for side projects, LLMs have become my new best friends. I'm more worried about the future of my students than my own. I'm sure I'll grow old gracefully alongside the machines that helped me graduate and build a career.

I run Python workshops on weekends, and honestly, I'm speechless at the things students are already doing. But is it realistic to encourage them to study computer science in a year or two, when it's still a 4-year degree? By the time they start uni, LLMs will be 100 times more powerful than they are today. And in 6 years?

Any advice?

[sealeck]

> With minor exceptions, moving from one language to another isn’t a matter of simple syntax, trivia, or swapping standard libraries.

I think this is not true for most programming languages. Most of the ones we use today have converged around an imperative model with fairly similar functionality. Converting from one to another can often be done programmatically!

[snoman]

The question isn’t whether there exists a function that can translate one language to another. If they’re Turing complete, it’s certainly the case that the same software CAN be written in different languages. The question is whether or not it would produce idiomatic code in the target language and whether or not you/the developer would recognize it as (not) idiomatic when it did.

You can’t tell me that precisely the same paradigms, mechanics, patterns and practices will be used to develop software in both Java/Spring and Ruby/Rails, for example. The way you need to (be able to) think about how you write the software using those two languages will be non-trivially different.

[kiitos]

I mean, absolutely and obviously not, right?

Like, languages aren't just different ways to express the same underlying concepts? It's clearly not the case that you can just transliterate a program in language X to language Y and expect to get the same behavior, functionality, etc. in the end?

[sealeck]

> It's clearly not the case that you can just transliterate a program in language X to language Y and expect to get the same behavior, functionality, etc. in the end?

You most definitely can; if you have Turing complete languages A and B, you can implement an interpreter for A in B and B in A; you can implement a simple X86/aarch64 interpreter in either A or B and use that to run compiled/interpreted programs in the other; you can also write higher-level routines that map to language constructs in one or the other to convert between the two.

[Tokumei-no-hito]

you have a point, "idiomatic" use of the language. what's unclear is whether idiomatic application of a language is a matter of elegance or functionality and is that idiomatic usage something captured by the training.

some elements are necessities to the language while others are more for the human / team.

[nojito]

How about converting a rust library into Haskell?

https://ghuntley.com/oh-fuck/

That's from 6 months ago and the tooling today is almost night and day in terms of improvements.

[amelius]

It really makes me wonder what is taking us so long to translate all these C python modules like Numpy and SciPy into something that works with one of the GIL-free python variants out there.

[nojito]

I have started pulling all my backlog projects of converting my feature complete python code over to rust and with Claude it's been absolutely phenomenal.

[fleebee]

Where can I see the code?

Also:

> This wasn't something that existed; it wasn't regurgitating knowledge from Stackoverflow. It was inventing/creating something new.

Didn't he expressly ask the LLM to copy an established, documented library?

[simonw]

Yes, but in another language. It wasn't regurgitating Haskell code it had seen before.

[snzixjxjxjsn]

Translation is the one thing everyone expects AI to be good at. And while I’m not an expert in above posts languages so I can’t review, I’d be willing to bet there’s not obvious mistakes that could end up being pretty significant. The same thing happens with language I’m an expert it.

It’s odd the post describes what it’s doing as creating something new - that’s only true in the most literal (intellectually dishonest) sense.

[exe34]

You can write Fortran in any language!

[diggan]

> moving from one language to another isn’t a matter of simple syntax, trivia, or swapping standard libraries. [...] Java to Scala, js to Java, or C# to Python

I find it kind of funny (or maybe sad?) that you say that, then your examples are all languages that basically offer the same features and semantics, but with slightly different syntax. They're all Algol/C-style languages.

I'd understand moving from Java to/from Haskell can be a bit tricky since they're actually very different from each other, but C# to/from Java? Those languages are more similar than they are different, and the biggest changes is just names and trivia basically, not the concepts themselves.

[AstroBen]

100%.

LLMs aren't good engineers. They're mediocre, overengineering, genius, dumb, too simplistic, clean coding, overthinking, underthinking, great but terrible engineers rolled into one. You can get them to fight for any viewpoint you want with the right prompt. They're literally everything at once

To get good code out of them, you have to understand what good code is in the first place and lead them to it

My experience is iterating through 5 potential options being like "nope, that wont work, do it this way.. nope adjust that.. nope add more of this.. oh yeah that's great!"

The "that's great!" made me nervous that an LLM was capable of producing code as good as me until I realized that I threw out most of what it gave.. and someone less experienced would've taken the first suggestion without realizing its drawbacks

[simonw]

> To get good code out of them, you have to understand what good code is in the first place and lead them to it

That's a great way of putting it. Completely agree.

[anon7000]

Completely agree. And along the way, my personal knowledge of bash has increased a lot, for example, just because I’m using it a lot more

[giancarlostoro]

LLMs are search engines not robots you can automate things with search engine results but you can also accidentally automate NSFW being delivered to customers. Use the right tools correctly.

[qsort]

This is 100% the rational response I'd give to OP, but I can't deny I feel a bit of the same unease. It's mostly that this technology is really... weird, I think. I struggle to put that into words if I'm being honest.

[kiitos]

> Previously .. I didn't want to take the time to spin up on the trivia for a new language or platform ... Now? I'll happily use things like Go and Bash and AppleScript and jq and ffmpeg

It's pretty wild that you're characterizing the understanding of a language and its details as "trivia" that you don't need to "take the time to spin up on" before you write programs in that language.

I mean, I get this perspective, but it's the position of a product manager, not a software engineer...

[simonw]

I stand by what I said. Knowing how to eg loop through every file in the current directory in Bash is trivia.

That's not to say it's trivial, or to disparage that knowledge. But it's not at the same level as understanding how eg Unix processes can be piped together.

If I'm interviewing a candidate and they can't remember the syntax for a Bash loop, I don't care. If they can't explain what happens when you pipe output from one process to another (at least at a high level), that's a problem.

[pglevy]

This way of putting it resonates with me: unlocking the value of fuzzy knowledge.