[localhoster]

Let's make it very clear - this is the original creator of redis, or one of them.

He is not "your avg dev" and it took him 4 months with llm.

This is not a seal of approval for you to go and command all your developers to move to Claude code/codex/any other ai coding tool fully.

I'm looking at you - any avg CEO of a startup.

[simonw]

It's a pretty strong endorsement for the idea that coding agents, used skillfully by experienced developers, can further amplify their expertise.

[zozbot234]

Sure but the OP suggests that these were minor gains, and that this limited scope for gains was necessary in order to preserve the quality standard that's long been expected in that FLOSS community. We aren't talking about either a 10x productivity gain or one-shotting entire new features from scratch.

This is arguably a key quote: "Then, it was time to read all the code, line by line. ... I found many small inefficiencies or design errors ... so I started a process of manual and AI-assisted rewrite of many modules." We should not underestimate that step: reading code line by line might easily require more time than writing it from scratch.

[simonw]

Right, and those of us who advocate for a sensible approach to agentic engineering don't talk about 10x productivity gains or one-shotting entire new (production-ready) features from scratch either.

I remain unconvinced by the "faster to write it by hand than read it" arguments though. My experience throughout my career is that most people, myself included, top out at a couple of hundred lines of tested, production-ready code per day. I can productively review a couple of thousand.

[FEELmyAGI]

"top out at a couple of hundred lines of tested, production-ready code per day" + " productively review a couple of thousand." + LLM agents that write code for you = apparent contradiction with your first paragraph.

[zozbot234]

Right, I don't think you can "productively review a couple thousand" lines of code per day. That would imply that the review step for this very patch only took a couple days in total (since the core code is described as 5k lines) which is rather implausible to say the least.

[skybrian]

Both Simon Willison and Antirez said that using LLMs helped them, so it's kind of perverse to read them and conclude the opposite.

In particular, doing direct comparisons between metrics like that doesn't work. "Lines of code" isn't a good way to measure complexity of the code, and the amount of time it takes to review the code will vary quite a bit based on the use case.

There's a lot of diversity in what kind of code people write and just because it worked for someone else doesn't mean it will work for the kinds of problems you solve. It's anecdotal evidence that someone else found it useful, your mileage may vary.

[merb]

BTW the last day. I played with Claude to fix the simple things all by himself. Sadly we are on gitlab so I needed to tell him to use glab cli and I needed a little bit more time to setup than GitHub (why do they not support gitlab or other code forges…) However it is definitely a time saver in these 1-3 line changes. My workflow basically was:

Let the LLM cook by doing the issues one by one. In the meantime I could start reviewing them. Checkout, running, reading. It was definitely faster since it also correctly linked everything, etc. of course once the change goes beyond that it probably is not working. However I really thought that a good idea would be to check for that work and implement it according to the issue description and change a Mr once the description changes, at least as long as the Mr is 1-3 lines. And even if it does not work, I can just discard it.

(A lot of these problems are often typos that do not even need a checkout, they come in through bigger Mrs that should not be blocked because of them)

[gfody]

> Sure but the OP suggests that these were minor gains

When antirez says 'I ventured to a level of complexity that I would have otherwise skipped,' I don't think you can call that a minor gain. The alternative is likely something 'good enough' that leaves the community dissatisfied for months, and then after initial design mistakes become load-bearing the ideal implementation can never be realized.

[zozbot234]

He writes that right after saying "For high quality system programming tasks you have to still be fully involved". He's just saying that AI was useful to him for tedious special-case tasks (citing the addition of 32-bit support and fishing out bugs in new low-level implementations), that this required starting from a "huge specification" (not a one-shotted prompt!) and that he still had to go over everything with a fine-toothed comb afterwards. That's the farthest thing from the 10x silver bullet AI is now being sold as.

[oulipo2]

Exactly. LLMs are good at "code inpainting": you give them the structures / constraints / specs, and they write the boilerplate.

Then you need a senior to go realize the 100 mistakes it did, fix them, and iterate, which is why you can't replace "natural intelligence"

And there are real mathematical reasons why computers won't be able to break through "mathematical reasoning" on their own (indecidability, etc)

[lelanthran]

> We should not underestimate that step: reading code line by line might easily require more time than writing it from scratch.

Might?

Reading code you did not write is always going to take more time if you do it properly.

[nl]

The author said "You know what was the biggest realization of all that?"

> For high quality system programming tasks you have to still be fully involved, but I ventured to a level of complexity that I would have otherwise skipped. AI provided the safety net for two things: certain massive tasks that are very tiring (like the 32 bit support that was added and tested later), and at the same time the virtual work force required to make sure there are no obvious bugs in complicated algorithms.

[oulipo2]

...which is VERY, VERY, FAR from "LLMs can automate coding" that people like to say, which is completely false

[nl]

That makes the title of another of his posts very ironic then:

"Automatic programming"

https://antirez.com/news/159

[robertlagrant]

Not really:

> I started to refer to the process of writing software using AI assistance (soon to become just "the process of writing software", I believe) with the term "Automatic Programming"

[DrammBA]

> He is not "your avg dev" and it took him 4 months with llm.

To clarify, from TFA:

> even before LLMs the implementation was likely something I could do in four months. What changed is that in the same time span, I was able to do a lot more

The initial timeframe was 4 months, he was able to do more work within the same timeframe with LLMs.

[tracker1]

I would add that the output was likely more as well.. ex: more thorough tests, documentation, etc.

I've been working on a Database adapter for a couple months using an LLM... I've got a couple minor refactors to do still, then getting the "publish" to jsr/npm working... I've mostly held off as I haven't actually done a full review of the code... I've reviewed the tests, and confirmed they're working though. The hard part is there's some features I really want when in Windows to a Windows SQL Server instance that isn't available in linux/containers. I don't think I'll ever choose SQL again, but at least I can use/access a good API with windows direct auth and FILESTREAM access in Deno/Bun/Node.

FWIW: My final implementation landed on ODBC via rust+ffi so after I get the mssql driver out, I'll strip a few bits in a fork and publish a more generic odbc client adapter. using/dispose and async iterators as first class features in the driver.

[slig]

>He is not "your avg dev" and it took him 4 months with llm.

He's not, but his work is obviously not average.

Average dev work is plumbing and CRUDs.

[jareklupinski]

it's honest work

[slig]

It is, and LLMs help me a lot doing honest work.

[mlmonkey]

This _is_ the original creator of Redis, and one of the best C coders out there, who writes impeccable C code.

[oulipo2]

Well that's mostly my point: LLMs are mostly useful now as "code inpainting" / "boilerplate writing" when you have a defined spec

I'm doing my work mostly the same as Antirez is doing, writing detailed spec (which is actually 80% of the hard work, even without LLMs), then where I would have written the "boring stuff" I use the LLM to "autocomplete", and then see all the mistakes (which require being a senior to see / fix), correct, and iterate

It makes the work "feel" easier because we mostly skip writing the boilerplate, but it still doesn't replace coders. And companies that think they will be able to skip training juniors (in order to later replace seniors) and still have seniors onboard are making a huge mistake

[artyom]

Antirez is 100% the creator of Redis. And not only that, it's the kind of mind that you probably only get "a handful each generation".