AI coding agents are removing programming language barriers
railsatscale.com
railsatscale.com
The end result? Non-mainstream languages don't get much easier to get into because average Joe isn't already proficient in them to catch AI's bugs.
People often forget the bitter lesson of machine learning which plagues transformer models as well.
I also use coding agents with Elixir daily without issues.
Obviously, this can also happen with Rust, but certainly less so than with C or C++, I'll give you that. But how is Rust the only way when there's also Java, Go, C#, Swift, Kotlin, etc.?
OpenAI uses Rust for their service development as do a lot of other big companies.
It's a lot like Python/Flask, or even a bit like Go. It's incredibly easy to author [1] and deploy, and it runs super fast with no GC spikes or tuning. Super predictable five nines.
Desktop apps sing when written in Rust. A lot of AI powered desktop apps are being written in Rust now.
If you're going to reach for Go or Java (gRPC or Jetty or something) or Python/Flask, Rust is a super viable alternative. It takes the same amount of time to author, and will likely be far more defect free since the language encourages writing in a less error prone way and checks for all kinds of errors. Google did a study on this [2,3].
[1] 99.9% of the time you never hit the borrow checker/lifetimes when writing server code as it's linear request scoped logic. You get amazing error handling syntax and ergonomics and automatic cleanup of everything. You also have powerful threading and async tools if you need your service to do work on the side, and those check for correctness.
[2] "When we've rewritten systems from Go into Rust, we've found that it takes about the same size team about the same amount of time to build it," said Bergstrom. "That is, there's no loss in productivity when moving from Go to Rust. And the interesting thing is we do see some benefits from it. So we see reduced memory usage in the services that we've moved from Go ... and we see a decreased defect rate over time in those services that have been rewritten in Rust – so increasing correctness." https://www.theregister.com/2024/03/31/rust_google_c/
In which world is Rust fantastic for writing desktop applications? Where are the mature Rust UI frameworks?
> Desktop apps sing when written in Rust.
What does this even mean?
> A lot of AI powered desktop apps are being written in Rust now.
For example? And what do you mean by "AI powered desktop apps"?
Rust has come a remarkably long way [1] !
It's better than any language that isn't C/C++. We have bindings to all of the major UI toolkits, plus a lot of native toolkits.
You can also use Electron/Tauri for Javascript, or Dioxus for something more performant. Egui is also really nice for dev tools.
> What does this even mean?
Rewrite It In Rust metrics tend to tell good stories.
Developer blogs (links escaping me right now) show positive performance gains for lots of consumer desktop software written in whole or in parts using Rust. Discord, Slack, lots of other apps are starting to replace under-performing components in Rust.
> For example? And what do you mean by "AI powered desktop apps"?
Stuff like Zed [2] and the open source Photoshop-killer I'm working on (user-guided volumetric rendering, real time instructive Figma). The creator or egui works on Rerun [3], which is industrial / spatial visualization. Etc, etc.
[2] https://zed.dev/
The only mature cross-platform UI frameworks I see in this list are written in C and C++ :) And of all the various Rust bindings for Qt, only a single one ("ritual") offers bindings to the Widgets API. Not only are these bindings unsafe, the project has also been abandoned. https://github.com/KDAB/cxx-qt/?tab=readme-ov-file#compariso.... Of course, this is not suprising, given that the API surface of Qt6 is huge and difficult (or impossible?) to safely wrap in Rust.
(The reality is that Rust's ownership model makes it rather awkward to use for traditional UI frameworks with object trees.)
Tauri looks neat, but the actual UI is a webview, so it's not everyone's cup of tea. (Certainly not mine.)
As you said, egui is cool for simple tools, but not suitable for complex desktop applications.
Yes, Rust has gotten quite a few desktop UI frameworks, but I don't see any industry standards yet. Don't forgot that Qt has been in development for 30 years now! Rust has a lot to catch up.
Rust code has the property that if it compiles, it usually works. True there are still runtime errors that can occur in Rust, but they're less likely going to be due to LLM hallucinations, which would be caught at compile time.
Can you elaborate a bit here? In my experience, most code I come into contact with isn't nearly defensive enough. Is AI generated code more defensive then the median?
some HDLs should fit the bill: VHDL, Verilog or SystemC
[1] https://docs.amd.com/r/en-US/ug901-vivado-synthesis/Flip-Flo...
I use AI assistance to generate code and review code, but I haven't had success trying to use it to update a substantial existing code base in Scala. I have tried using both Claude Code and Cursor and the handful of times I tried there were so many oversights and mistakes that resolving the mess was more effort than doing it manually. I'll probably try again after the next big model releases.
Current frontier models have been the least useful to me when I'm asking them to review performance-critical code inside Scala. These are bits of my code base that I have written to use a lot of mutable variables, mutable data structures, and imperative logic to avoid allocations and other performance impediments. I only use this style for functions highlighted by profiling. I can ask for a code review and even include the reasoning for the unusual style in the docstring, but Claude and Gemini have still tried to nudge me back to much slower standard Scala idioms.
im building one that lets you write and enforce your own rules so you don't get the typical slop
email in profile if you'd like to try it - i can send you a link
Just found 3 race conditions in 100 lines of code. From the UTF-8 emojis in the comments I'm really certain it was AI generated. The "locking" was just abandoning the work if another thread had started something, the "locking" mechanism also had toctou issues, the "locking" also didn't actually lock concurrent access to the resource that actually needed it.
I've copied thousands of lines of complex code into an LLM asking it to find complex problems like race conditions and it has found them (and other unsolicited bugs) that nobody was able to find themselves.
Oh it just pattern matched against the general concept of race conditions to find them in complex code it's never seen before / it's just autocomplete, what's the big deal? At that level, humans are glorified pattern matchers too and the distinction is meaningless.
How did you evaluate this? Would be interested in seeing results.
I am specifically interested in the amount of false issues found by the LLM, and examples of those.
There are false positives, and they mostly come from the LLM missing relevant context like a detail about the priors or database schema. The iterative nature of an LLM convo means you can add context as needed and ratchet into real bugs.
But the false positives involve the exact same cycle you do when you're looking for bugs yourself. You look at the haystack and you have suspicions about where the needles might be, and you verify.
You do or you don't.
Recently we've seen many "security researchers" doing exactly this with LLM:s [1]
1: https://www.theregister.com/2025/05/07/curl_ai_bug_reports/
Not suggesting you are doing any of that, just curious what's going on and how you are finding it useful.
> But the false positives involve the exact same cycle you do when you're looking for bugs yourself.
In my 35 years of programming I never went just "looking for bugs".
I have a bug and I track it down. That's it.
Sounds like your experience is similar to using deterministic static code analyzers but more expensive, time consuming, ambiguous and hallucinating up non-issues.
And that you didn't get a report to save and share.
So is it saving you any time or money yet?
It's a hard, time consuming, and meandering process to do this kind of work on a system, and it's what you might have to pay expensive consultants to do for you, but it's also how you beat an expensive bug to the punchline.
An LLM helps me run all sorts of considerations on a system that I didn't think of myself, but that process is no different than what it looks like when I verify the system myself. I have all sorts of suspicions that turn into dead ends because I can't know what problems a complex system is already hardened against.
What exactly stops two in-flight transfers from double-spending? What about when X? And when Y? And what if Z? I have these sorts of thoughts all day.
I can sense a little vinegar at the end of your comment. Presumably something here annoys you?
Thanks for your responses.
Really sorry about the vinegar, not intentional. I may have such personality disorder idk. Being blunt, not very great communication skills.
My vice is when someone writes a comment where I have a different opinion than them, and their comment makes me think of my own thoughts on the subject.
But since I'm responding to them, I feel like it's some sort of debate/argument even though in reality I'm just adding my two cents.
[1]https://ai.vixra.org/pdf/2506.0065v1.pdf
The paper is satire, but it's a pretty funny read.
The counter point is how LLMs can't find a missing line in a poem when they are given the original.
PAC learning is basically existential quantification...has the same limits too.
But being a tool to find a needle is not the same as finding all or even reliability finding a specific needle.
Being being a general programming agent requires much more than just finding a needle.
True, but describing a limitation of the tech can't be used to make the sort of large dismissals we see people make wrt LLMs.
The human brain has all sorts of limitations like horrible memory (super confident about wrong details) and catastrophic susceptibility to logical fallacies.
Have you not had this issue with LLMs? Because I have. Even with the latest models.
I think someone upthread was making an attempt at
> describing a limitation of the tech
but you keep swatting them down. I didn’t see their comments as a wholesale dismissal of AI. They just said they aren’t great at sufficiently complex tasks. That’s my experience as well. You’re just disagreeing on what “sufficiently” and “complex” mean, exactly.
“Pattern matching” is thought of as linear but LLMs are doing something more complex, it should be appreciated as such.
I'm still convinced that this is true. The more advances we make in "AI" the more i expect we'll discover that we're not as creative and unique as we think we are.
Even our memories are mutable. We will with full confidence recite memories or facts we've learned just moments ago which are entirely fictional. Normal, healthy adults.
Humans generally have a very high opinion of themselves and their supposedly unique creative skills. They are not eager to have this illusion punctured.
This is one of the "here be demons" type signatures of LLM code generation age, along with comments like
// define the payload struct payload {};
Things that most teams don’t do or half-ass
That's not really true for things that are changing a lot. I got a terrible experience last time I've tried to use Zig, for example. The code it generated was an amalgamation between two or three different versions.
And I've even got this same style of problem in golang where sometimes the LLM generates a for loop in the "old style" (pre go 1.22).
In the end LLMs are a great tool if you know what needs to be done, otherwise it will trip you up.
But I'm not noticing that anymore, at least with Elixir. The gap has closed; Claude 4 and Gemini 2.5 both write it excellently.
Otoh, if you wanted to create an entirely new programming language in 2025, you might be shit outta luck.
This just made me really sad. That effectively means that we'll plateau indefinitely as a civilization (not just on programming languages, but anything where the LLM can create an artificial Lindy effect).
Or, do what you want, and don't worry what language people who have no interest in programming use.
Also, I had created a custom Node.js/JavaScript BaaS platform with custom Web Components and wanted to build apps with it, I gave it the documentation as attachment and surprisingly, it was able to modify an existing app to add entire new features. This app had multiple pages and Claude just knew where to make the changes. I was building a kind of marketplace app. One time it implemented the review/rating feature in the wrong place and I told it "This rating feature is meant for buyers to review sellers, not for sellers to review buyers" and it fixed it exactly right.
I think my second experience (plain JavaScript) was much more impressive and was essentially frictionless. I can't remember it making a single major mistake. I think only once it forgot to add the listener to handle the click event to highlight when a star icon was clicked but it fixed it perfectly when I mentioned this. With TypeScript, it sometimes got confused; I had to help it a lot more because I was trying to mock some functions; the fact that the TypeScript source code is separate from the build code created some confusion and it was struggling to grep the codebase at times. Though I guess the code was also more complicated and spread out over more files. My JavaScript web components are intended to be low-code so it's much more succinct.
Even for small projects the optimisation criteria is different if the human's role in the equation shifts from authoring to primarily a reviewing based one.
I'm optimistic that most new programming languages will only need a few "real" programmers to write a small amount of example code for the AI training to get started.
CSV is not a complex format.
Why do you reach this conclusion from toying with CSV?
And why do you trust a LLM for economic planning?
When the code is done, it not like the LLM can secretly go flip columns at random
Zig changes a lot. So LLMs reference outdated data, or no data at all, and resort to making a lot of 50% confidence guesses.
With Rust OTOH Claude feels like a great teacher.
Strong typing drastically reduces hallucinations and wtf bugs that slip through code review.
So it’ll probably be the strongly typed languages that receive the proportionally greatest boost in popularity from LLM-assisted coding.
goimports makes everything look the same, the compiler is a nitpicky asshole that won’t let the program even compile if there is an unused variable etc.
That is a really big advantage in the AI era. LLMs are pretty bad at identifying what is and what isn't relevant in the context.
For developers this decision is pretty annoying, but it makes sense if you are using LLMs.
When you have a standard build process that runs go vet, go test, golanci-lint, goimports and compiles the code you can order the LLM to do that as the last step every time.
This way at the very least the shit it produces is well-formed and passes the tests :)
Otherwise they tend to just leave stuff hanging like "this erroring test is unrelated to the current task, let's just not run it" - ffs you just broke it, it passed perfectly before you started messing with the codebase =)
If they do want "popularity" then the counter-counter-point is that it should be easier to get than ever. Just have one proficient person write a lot of idiomatic, relatively isolatable code, and then have an AI generate terabytes upon terabytes of public domain licensed variations and combinations on that code. If you make programming in the small a breeze, people will flock to your language, and then they can discover how to program in the large with it on their own time.
Alternatively every new release will have to come with an MCP for its documentation and any other aspects that might make it easier for an LLM to talk about it and use it accurately.
>For someone who spent a decade as a “Ruby developer,” becoming a multi-language developer in less than a year feels revolutionary.
Revolutionary? They've snitched they have no frame of reference to make that claim. It would have taken "less than a year" with or without AI. They just spent 10 years not trying.
Everyone's first language learning experience is also learning to program. Learning a new language once you have years of professional programming practice is completely different.
In my early days, I identified strongly with my chosen programming language, but people way more experienced than me taught me that a programming language is a tool, and that this approach is akin to saying "well, I don't know about those pliers, I am a hammerer."
My personal feeling from working across a wide range of programming languages is that it expands your horizons in a massive way (and hard to qualitatively describe), and I'm happy that I did this.
What you may have missed, from the perspective of your vertically scaled horse, is that you compare learning certain models to a mental disability. It makes calling my comment racist similar to the whole pot/kettle thing.
However, I do appreciate reading about such opinions because it offers a peek into the elitism that surrounds programming languages.
Also, as a person from a non-traditional and non-privileged background, Im a little unsure about how to proceed. Shall we cut our losses and move on?
The language I consider the lamest, biggest impediment to learning computer science is used by some of the smartest people on the planet to build amazing things.
I suppose we can mark this statement as technically true. I can only attest to my experience using o4 for python mini projects ( popular, so lots of functional code to train on ).
The thing I found is that without it, all the interesting little curve balls I encountered likely would have thrown a serious wrench into the process ( yesterday, it was unraid specific way of handling xml vm ). All of sudden, I am not learning how to program, but learning how qemu actually works, but it is a lot more seamless than having to explore it 'on my own'. And that little detour took half a day when all was said and done. There was another little detour at dockers ( again unraid specific isseus ), but all was overcome, because now I had 4o guide me.
It is scary, because it can work and work well ( even when correcting for randomness). FWIW, my first language was basic way back when.
Incremental obviously is the ideal version especially from long term perspective if the plan for it is decent, but it is simply not always as useful in real world.
Not to search very far, I can no longer spend more than a day on pursuing random threads ( or intentional ones for that matter ).
I guess what I am saying is: learning from first principles is a good idea if you can do it that way. And no for docker example. You learn how they should work. When playing in real world, you quickly find out there are interesting edge cases, exceptions and issues galore. How they should work only gets you so far.
Project have a more long term objective. What’s important is the consistency and alignment of the individual tasks. In learning terms, that may be a book, a library docs, some codebase. The most essential aspect is that they have an end condition.
Areas is just thing that you have to do or take care of. The end condition is not fully set. In learning terms, these are my interest like drawing or computer techs. As long as something interesting pops up, I will consume it.
It’s very rare for me to have to learn stuff without notice. Most will fall under an objective or something that I was pursuing for a while.
Being in the zone of proximal development will do that: https://en.wikipedia.org/wiki/Zone_of_proximal_development
We shouldn't dismiss high friction problems.
Is there any large formally verified project written in Haskell? The most well known ones are C (seL4 microkernel) and Coq+OCaml (CompCert verified C compiler).
You pretty much don’t need to plug another language into Haskell to be satisfied about certain conditions if the types are designed correctly.
Now, I believe GHC also has support for dependent types, but the question stands: are there any major Haskell projects that actually use all of these features to formally verify their semantics? Is any part of the Haskell standard library formally verified, for example?
And yes, I do understand that type checking is a kind of formal verification, so in some sense even a C program is "formally verified", since the compiler ensures that you can't assign a float to an int. But I'm specifically asking about formal verification of higher level semantics - sorting, monad laws, proving some tree is balanced, etc.
> Their main proof strategy is to prove the Haskell version correct; then prove the C version matches the Haskell version.
However, I don't think this is right. By my understanding of the paper, the Haskell implementation isn't proven to be correct, it's more of a prototyping tool. The Haskell version is used as an intermediate representation that can be automatically translated into Isabelle/HOL and quickly proven to have various properties. If the proofs don't work at this level, it's easy to change, re-translate, and re-check. To make it easily tramslatable to Isabelle/HOL, they forego many Haskell features, such as typeclasses, or making use of laziness. The Haskell program is also designed to match the eventual C implementation, so it's using C-like data types, pointers, etc - not native Haskell data structures,nor making use of the Haskell GC.
The proofs achieved at this level apply to the auto-generated Isabelle/HOL translation of the Haskell code. The Haskell runtime is not modeled here in any way, and as such the proofs do not hold for the Haskell executable code that you can run on the simulator.
The Haskell prototype was then translated manually to C, trying to keep as close to a 1:1 translation as possible, while still allowing various micro-optimizations. Then, the exact C code was manually translated back to Isabelle/HOL, where they also had a complete model of the semantics of every C statement that they used (they use a subset of C, with the biggest missing feature being references to local variables - you can't use &x if x is a local variable in their C code). Isabelle/HOL was then used to check that this manually written implementation implemented the abstract specification with all of the proven guarantees.
So, the Haskell part was ultimately a convenience, not a fully necessary part of the proof (though the whole thing would probably not have been feasible had they not used it). It was a decent middle ground between being possible for the kernel devs to define the code in it, and the formal verification guys to translate it to Isabelle and verify it. If they had tried to write the C code directly, the cost of translating any change to the C code back to Isabelle for verification would have been too high. Conversely, having the kernel devs learn enough Isabelle to define the prototype code directly in Isabelle would have also been too complicated as well - and I believe the Isabelle code could not be easily executed to be able to do more regular debugging on it during the development process, the way the Haskell code could be run on the simulator.
[0] https://www.sigops.org/s/conferences/sosp/2009/papers/klein-...
I think people, who care about FP, should think about what is appealing about coding in natural language and is missing from programming in strongly typed FP languages such as Haskell and Lean. (After all, what attracted me to Haskell compared to Python was that the typechecking is relatively cheap thanks to type inference.)
I believe that natural language in coding has allure because it can express the outcome in fuzzy manner. I can "handwave" certain parts and the machine fills them out. I further believe, to make this work well with formal languages, we will need to use some kind of fuzzy logic, in which we specify the programs. (I particularly favor certain strong logics based on MTL but that aside.) Unfortunately, this line of research seems to have been pretty much abandoned in AI in favor of NNs.
LLMs don't use the LSP exploratory to learn the API, you just give it to it as a context or MCP tool. LLMs are really good at pattern matching and wont make type errors as long as the type structure and constructs are simple.
If they are not simple it is not said that the LLM can solve and the user understand it.
I think languages with more minimal features and really good compile time errors would work well with LLMs. In particular, I've heard multiple people say how good LLMs are at generating Go.
Personally, I like languages with type inference so this wouldn't be my preference.
I think this is the most important thing mentioned in the post. In order for the AI to actually help you with languages you don't know you have to question its solutions. I have noticed that asking questions like why are we doing it like this and what will happen in the x,y,z scenario, really helps.
For example: - I implement something. - Then I ask it to review it and suggest alternatives. Where it will likely say my solution is the best. - Then I say something like "Isn't the other approach better for __reason__ ?". Where the approach might not even be something it suggested.
And it seems that sometimes it gives me some valid points.
That's how I've been using it.
I treat it as a partner that has a "wide and shallow" initial base, but the ability to "dive deep," when I need it. Basically, I do a "shallow triage," to figure out what I want to focus on, then I ask it to "dive deep," on my chosen topic.
I haven't been using it to learn new languages, but I have been using it to learn new concepts and techniques.
Right now, I'm learning up on implementing a webauthn backend and passkey integration into my app. It's been instrumental. Coming along great. I hadn't had any previous experience, and it's helping me to learn.
I should note that it has given me wrong examples; notably, it assumed a deprecated dependency version, that I had to debug and figure out a fix. That was actually a good thing, as it helped me to learn the "ins and outs" a bit better.
I'm still not convinced that I'd let AI just go ahead and ship an application from scratch, without any intervention on my part. It often makes mistakes; not serious ones, but ones that would be bad, if they shipped.
It got it wrong. The command was generated outside of the for, and never updated inside the loop effectively making it useless.
Luckily I know bash so I spotted it immediately. But I wonder how it's "removing programming language barriers" when one that does not know its output language can not spot even such a glaring issue.
Also, I out-of-hand reject any criticism of an AI that specifies only the brand ("ChatGPT") and not the specific model version, settings, etc...
So, for example, Gemini 2.5 Pro (Jan 2025) with temperature 0.15 prompted with: "Write a short, idiomatic bash script that takes a file containing a list of directory names, changes to each one, runs a command, and then returns to the original working directory."
Spits out this:
#!/bin/bash
# A script to run a command in a list of directories.
# Exit if the wrong number of arguments are provided.
if [[ $# -lt 2 ]]; then
echo "Usage: $0 <file_with_dirs> <command> [args...]" >&2
exit 1
fi
DIR_FILE="$1"
shift # The rest of the arguments ("$@") are now the command.
# Ensure the directory list file exists and is readable.
if [[ ! -r "$DIR_FILE" ]]; then
echo "Error: Cannot read file '$DIR_FILE'" >&2
exit 1
fi
# Read the file line by line.
while IFS= read -r dir; do
# Skip empty lines or non-existent directories.
if [[ -n "$dir" && -d "$dir" ]]; then
echo "==> Entering '$dir'..."
# Run command in a subshell to keep the 'cd' local.
# '&&' ensures the command only runs if 'cd' succeeds.
(cd "$dir" && "$@")
echo "<== Finished with '$dir'."
else
echo "--> Skipping invalid directory: '$dir'" >&2
fi
done < "$DIR_FILE"
echo "All done."
Something that I found amusing, and again, is a criticism of bash instead of the AI, is that this fails to process the last line if it isn't terminated with a \n character.
PS: This is almost a one-liner in PowerShell, and works with or without the final terminator character:
Push-Location
Get-Content dirs.txt | cd -PassThru | Foreach-Object { echo "Hello from: $pwd" }
Pop-Location
pushd;gc dirs.txt|%{cd $_;"Hello from: $pwd"};popd for dir in $(cat dirs.txt); do ( cd "$dir"; echo "Hello from $(pwd)" ); doneFundamentally, bash is just... verbose.
I.e.: Here's the same task implemented in two scripting languages:
PowerShell is 5 lines of code: https://learn.microsoft.com/en-us/azure/virtual-machines/ena...
Bash is several pages: https://learn.microsoft.com/en-us/azure/virtual-machines/ena...
I can write correct bash; Gemini in this instance could not.
> Also, I out-of-hand reject any criticism of an AI that specifies only the brand ("ChatGPT") and not the specific model version
Honestly I don't care, I opened the browser and typed my query just like anyone would.
> PS: This is almost a one-liner in PowerShell, and
Wonder how this is related to "I asked Gemini to generate a script and it was severely bugged"
Yes, well... are you "anyone", or an IT professional? Are you using the computer like my mother, or like someone that knows how LLMs work?
This is a very substantial difference. There's just no way "anyone" is going to get useful code out of LLMs as they are now, in most circumstances.
However, I've seen IT professionals (not necessarily developers!) get a lot of utility out of them, but only after switching to specific models in "API playgrounds" or some similarly controlled environment.
I have more than 15 years of programming experience. I do not trust the output of LLMs a single bit. This just proved my point. I honestly don't care if I used the "wrong" model or the "wrong" query, which was already quite descriptive of what I wanted anyway.
No need to get super defensive, you can keep spending your time playing code golf with Gemini if you want. My experience just corroborates what I already thought; code generation is imprecise and error prone.
If you used the wrong SQL query, would you expect the right answer?
If you used the wrong database, would you expect your app to work well?
I’ve done similar tools with Go and haven’t had any issues.
One goes through a tree of dirs, finds zip files with images, unzips, benchmarks which image format is the most compact and creates a new zip with that.
Got it right the first go (hehe pun)
But meaningfully contributing to a complex project without the skills? Not a chance I'd put my name on the contributions it makes. I know how many mistakes these tools make in the languages I know well - it also makes them in the ones I don't. Only now I can't review its output
Whenever I dive into a programming language I don’t know, I realize the amount of stuff I need to get used to before I feel confident reviewing code in it.
Also supposedly language barriers are smaller than ever, yet WhatsApp is killing its desktop app on Windows in favor of using the Web-based version.
I fear that this LLM stuff is turning this up 11. Now you're not even just doing trial and error with the compiler, it's trial and error with the LLM and you don't even understand what it's output. Writing C or assembly without fully reasoning about what's going on is going to be a really bad time... No, the LLM does not have a working model of computer memory, it's a language model, that's it.
I have worked in many, many languages in the past and I've always found it incredibly easy to switch, to the point where you're able to contribute right away and be efficient after a few hours.
I recently had to do some updates on a Kotlin project, having never used it (and not used Java in a few years either), and there was absolutely no barrier.
Just shellcheck the hell out of it until it passes all tests.
They don't struggle to write code, but they struggle to write idiomatic code.
An experienced programmer from a different language introduced to another will write lots of code that works, but in a style idiomatic to their favoured language, be that C, C++, rust, python, etc.
Every language has its quirks, and mastery is less about being able to write a for loop or any given algorithm in any given language, but more about knowing which things you should write, and which things you should be using the standard libraries for.
I've literally seen C# consultants waste time writing their favourite .NET LINQ methods into a javascript library, so they can .Select(), .Where(), etc, rather than using .filter, .map, etc.
Likewise I've seen people coming from C struggle to be as productive as they ought to be in C#, because they'd rather write a bunch of static methods with loops than get to grips with LINQ.
Fully understanding a runtime (or compiler behaviour for AOT languages) and what is or isn't in standard libraries isn't something that can be mastered in a few hours.
It almost never misses on explaining how certain syntax works.
If I think about the 10 most common languages being used for application code right now, something like 80% of them can be described as "C or ALGOL's syntax with call-by-reference and automatic memory management". If you program for a living, I feel like you can switch between any of these without much effort. They're so similar to one another at a fundamental level, and there's lots of convergence going on as they adopt features from one another.
Sure, doing C or C++ for the first time can be hard if you've never had to think about memory lifecycles before, but even that isn't so crazy if you're working with established patterns, pay attention to warnings, and use an aggressive linter.
For languages with actual learning curves, they're just not as widely used (e.g. Rust, Ada SPARK, lisp, forth, ML).
The hardest to learn for me was Haskell. Because of how different the thinking behind the language is. But it was great to learn even though I don't use it daily.
I highly recommend learning different programming languages. It's a great way to get exposed to different ways of thinking about how software should be developed.
AI is a much better, so in some case worse, language lawyer than humans could ever be.
Context windows are pretty large (Gemini 2.5 pro with 1 mill tokens (~ 750k words the largest) so it does not really matter.
I suggest that the author should properly read up on the technicals of these compiled languages before having to be fully dependent on an AI bot which by his own admission can lead him and the chatbot into the wrong direction.
Each of these languages all have different semantics and have complete differences between them; especially compiled languages like C/C++,Rust verses Ruby and Javascript (yuck).
I still spend a few days studying Rust to grasp the basic things.
The robot responds, "Can you?"
If you ask an LLM to generate a Go handler for a REST endpoint, it often does something a bit out of step with the rest of the code base. If I do it in Python, it's more idiomatic.
P.S. Maybe we will finally see M-expressions for Lisp developed some day? :)
AI code review helps you catch issues you've forgotten about and eliminates the repetitive work
These tools are helping developers create quality software - not replace them
If AI had really a multiplying factor here, I'd expect you to BE an expert.
sometimes it recommends high-level architectural changes.
sometimes it detects "inconsistent" things that step out of the line of non-trivial patterns. saved me tons of time in K8S and other large config YAMLs and in just imperative code too (structures there repeats often too)
and about correctness of suggestions. they are obvious once you see them. tests pass by definition (if you have any, before Copilot kicks-in). so whatever Copilot suggests likely already passes the tests, yet not ... sit right with it. it's intuition is pretty remarkable.
amount of QA and real-world bash runs, exploratory Go programs, code tinkering, research, manipulation, is outstanding
this poor thing did incredible amount of QA and experimentation work to get it right. and it did! very complex task.
required only nudging in the right high-level direction
Compare it yourself with letting it generate js/python or something it trained alot on, versus something more esoteric, like brainfuck.
And even in a common language, you'll hit brick walls when the LLM confuses different versions of the library you are using, or whatever.
I had issues with getting AI generated rust code to even compile.
It's simple: The less mainstream language, the less exposure in the training set leads to worse output.
Can you though? Or is just not bad enough for your coworkers to bother telling you how bad it is?
I use AIs daily. But that doesn't mean I don't get mad when I'm reviewing a coworker's work and have to fight whatever bullshit an AI convinced them. I can't just brush it off as AI nonsense because 1) it might be their honest attempt at work without AI and 2) if it is AI they've already proven they don't know how to improve it.
Take a look at this Haskell program that LLM wrote. I do not write Haskell, but I can review the code just fine to say that this is doing what I want.
-- Simple multiplication function
multiply :: Num a => a -> a -> a
multiply x y = x * y
-- Main function for running the program
main :: IO ()
main = do
putStrLn "Enter the first number:"
input1 <- getLine
putStrLn "Enter the second number:"
input2 <- getLine
let num1 = read input1 :: Double
let num2 = read input2 :: Double
let result = multiply num1 num2
putStrLn $ "Result: " ++ show num1 ++ " * " ++ show num2 ++ " = " ++ show result
It really is an NP problem, come to think of it.
So did you learn all of that from just glancing at this snippet?