Hacker News Reader

Comment by schrodinger | Hacker News Reader

Quick tangent if you’re willing to humor me…

I've been noticing that many new projects that would have been written in Python or Node a year ago are starting to be written in Go, Rust, etc.

Theory: people realized there’s little benefit to Python for agents. As Zep wrote, an “agent is a long-running, concurrent, I/O-bound process that spends most of its time waiting on a model, a tool, or a human[1]” — not a particular strength of Python.

I'm wondering if you'd considered Go (or others—Go’s just my fav ) before landing on Node, and more broadly whether you've noticed a similar pattern?

1: https://blog.getzep.com/agentic-development-in-go/

View on HN

> As Zep wrote, an “agent is a long-running, concurrent, I/O-bound process that spends most of its time waiting on a model, a tool, or a human[1]” — not a particular strength of Python.

That sounds exactly like a strength of Python, no? Python is excellent at working IO blocks and waiting in general being interpreted language with first-class async support.

Right. Python is excellent at waiting on things instead of actually doing things, and on the off case it does do things, most of the time it's really juggling strings around the thing instead of doing it.

I generally don't write Python, but like others, I disagree with GP too. In fact, a lot of my work involves Python being written now, simply because that's what LLMs like to write.

Yes, without the sarcasm.

Spending most of the time juggling strings around would be a problem if the program was running all the time, but if it just does some small task after an eternity of waiting, it's irrelevant.

Is that so? I feel like I’m seeing more Python and TypeScript than ever, especially when it comes to AI tooling, which is disappointing.

I can’t fathom why anybody would want to continue working with dynamically typed languages when they can now get types for free.

I suspect a lot of the Python and TypeScript code is getting prompted by folks who don't know any difference between dynamically typed and statically typed.

In the early days of LLM coding, it seemed to be much better at Python for whatever reason. I was never a big Python guy, but I got better results so I ran with it. That definitely doesn't seem to be the case anymore. Last week I asked Codex to mash up Super Mario Bros and Contra ROMs and it just did everything in straight assembly and absolutely crushed it. It couldn't do that 2 years ago. Python is just momentum and I think it's going to die down now that the models are much better.

Don’t want Nintendo to sue you (over [a] game/s you may well actually own!) so withhold my follow-up :)

Huh?

> I asked Codex to mash up Super Mario Bros and Contra ROMs

Did this create a new game? And did you publish the result? Might’ve misunderstood.

No, of course I didn't publish it.

Of course not.

What does mashing up roms mean? Like use sprites of one game in another or something like that?

Almost all my tool/skill scripts are in python purely because the standard library has almost everything under the sun in it.

Are you familiar with the Go standard library? It’s notorious for its comprehensiveness and how often you can write zero dependency applications as a result.

And there’s a reason: the Go designers were huge Python fans, so leaned on its design quite a bit. They essentially wanted to make a modern Python with first class support for static typing and highly scalable parallelism, not just concurrency.

It's too late to edit, but in retrospect I realize that the first sentence of that comment sounded awfully snarky, and I didn't mean it to. I apologize, and please trust it was asked in good faith.

Fully agree with you, and I didn't make my point well — I should have been more clear.

While Python and Node have undoubtedly seen a huge spike since the advent of mainstream AI, relatively recently I've begun to notice a small but growing trend of people switching away from or back to languages like Go and Rust. In an absolute sense, yes, Python is still dominating and growing.

The trend I have noticed is a very small but growing cohort of folks who are coming back to languages like Go and Rust.

Go and rust have better guardrails that help agents write better code. Python and JS aren't opinionated enough.

I agree with that — One of Go's biggest strengths is the flip side of an arguable weakness: it's not a very expressive language.

The positive of that is that if you ask three people to write the same function, it'll most likely end up nearly identical. You don't get codebases where different areas are written using different styles and different patterns.

This same effect applies equally to coding agents.

I think it's because python is far more approachable/ubiquitous than go/rust. It's the entry level language for many people from all disciplines of life. Scientific community uses it, data science uses it.

Golang/rust however are very convenient to distribute. Small, portable, fast exe's are very nice. With agentic coding golang/rust are now accessible to a lot more people.

> python is far more approachable

I see where you're coming from, but to be honest I respectfully disagree. If all you mean to do is writing small one-off scripts then sure Python may be the right tool[1], but when you're doing something more complicated Go is just simpler. And for an LLM, Go is even better for all the reasons mentioned in sibling comments and OP.

[1]: I tend to rely more on Bash, though...

Yes, now that humans write less than 99% of code, the most important criteria for a language isn't readability, which I'd argue was always Python's main selling point, but the underlying runtime. There are practical limits to how fast a Python program can run either under I/O or CPU bound compared to other popular and mature languages with extensive libraries, like Elixir, Go or C++, depending on your use case.

> now that humans write less than 99% of code, the most important criteria for a language isn't readability

please tell me you're reading the AI code

Not really. I test the output thoroughly, I examine the thinking process, I go through the diff to see if anything jumps out but I my thinking process/the way I work has changed. Low level programming thinking has gotten atrophied it seems.

Have it run fuzz and test suites. Get with it man. Most of my LLM projects have massive test suites that do a far better job then I ever would have.

So you're fine with your code having unintended behaviour, as long as that unintended behaviour passes a test that the agent wrote?

My preferred approach is to read and understand everything the LLM produces AND have it create test suites (which I also read and understand). The LLM can help you with that too - just have it breakdown and explain the code at each iteration.

If it's code for a pacemaker, it should be reviewed by multiple humans. If it's code for an unimportant side project, I will never read it. Between those extremes are shades of grey.

Part of our job in this new era is to understand the worst-case consequences of a bug given how the code interacts with the world, then allocate our effort based on that understanding. This can only be done on a case by case basis.

If you don't, at a bare minimum, read the code once though, you don't know how it interacts with the world.

Did you look at those test suites? Sometimes they test nothing.

Yes, but not all - it has been a long time in my experience that frontier LLMs have written nonsense tests.

I actually don't read any code! For generation I use simulations to ensure satisfactory error rates, for deterministic code I use test suites, and for user interfaces I use good ol' intuition! So I guess you could say I just write extra code that makes reading the code unnecessary. I find it quite strange to be honest! But this is the most effective way for me to ship now.

Go really feels like it was build for agentic development. Surprised it's not more popular than Rust.

Reply on news.ycombinator.com