HN user
The "Why" section exclusively opens with a reference to zstd-rs:
Why though?
Using zstd in Rust is already supported via the zstd crate, so why bother with a whole new implementation?
Separately, I'd say their end goal seems to be replacing the C library dependency in Rust's zstd-rs:
We have our own fork of the zstd that uses libzstd-rs-sys instead of the C library. We'd like to upstream this at some point.
Yes, and IBM has current documentation if you need to that has been updated in 2026: https://www.ibm.com/docs/en/zos/3.2.0?topic=considerations-u...
It's generally and simply an encoding of what amounts to binary machine code which you translate via assembly code acting as a deterministic compiler from assembly to machine code if you are doing it manually.
LLMs aren't a deterministic process and human languages aren't as clear as machine code and assembly.
The CDC recommends against heating milk in a microwave[0] whether it's human milk or formula meant for a baby due to the creation of "hot spots" and also the potential destruction of nutrients.
[0] https://www.cdc.gov/infant-toddler-nutrition/formula-feeding...
"Flappy Bengt"[0] is broken at least on my browser it's not playable as a human (nor LLM) due to requiring too large of an APM for anything but TASbot or a special purpose mechanical robot to play.
Which ones are you claiming have already been achieved?
My understanding of the current scorecard is that he's still technically correct, though I agree with you there is velocity heading towards some of these things being proven wrong by 2029.
For example, in the recent thread about LLMs and solving an Erdos problem I remember reading in the comments that it was confirmed there were multiple LLMs involved as well as an expert mathematician who was deciding what context to shuttle between them and helping formulate things.
Similarly, I've not yet heard of any non-expert Software Engineers creating 10,000+ lines of non-glue code that is bug-free. Even expert Engineers at Cloud Flare failed to create a bug-free OAuth library with Claude at the helm because some things are just extremely difficult to create without bugs even with experts in the loop.
"Code is a liability. What the code does for you is an asset." as quoted from https://wiki.c2.com/?SoftwareAsLiability with Last edit December 17, 2013.
This discussion and distinction used to be well known, but I'm happy to help some people become "one of today's lucky 10,000" as quoted from https://xkcd.com/1053/ because it is indeed much more interesting than the alternative approach.
Meanwhile, my cofounder is rewriting code we spent millions of salary on in the past by himself in a few weeks.
Code is not an asset it's a liability, and code that no one has reviewed is even more of a liability.
However, in the end, execution is all that matters so if you and your cofounder are able to execute successfully with mountains of generated code then it doesn't matter what assets and liabilities you hold in the short term.
The long term is a lot harder to predict in any case.
I'm glad we agree.
Interesting and thanks for clarifying that aspect. I have a few more questions if you would be able to answer any of them at any level of detail I would appreciate it.
How much would you be willing to pay to continue using Claude on a monthly basis before you stopped?
Do you currently maintain the new (as of two weeks ago) cash reserve to ensure it continues working when limits are reached and how much do you reserve for said reserve?
Finally, do you send your customer's code or data directly to Claude or do you use it indirectly on generic stuff and then manually specialize the outputs?
Again, I disagree and reaffirm my being full of inquisitiveness.
You are being downright unpleasant and I don't think we should continue this conversation further until you open your mind.
I'm inquisitive not narrow minded.
The GP didn't mention anything about freelancing so unless you know them or stalked them you are perhaps being narrow minded here.
It sounds like you use your personal Claude Code subscription for work of your employer, but that is not something I would ever consider doing personally so I imagine I must be mistaken.
Can you elaborate slightly on what you pay for personally and what your employer pays for with regards to using LLMs for Enterprise ERP?
Thank you for the explanation, but I did fully understand that is what you were saying.
What I don't fully understand is how you can characterize that as "not limited" with a straight face; then again, I can't see your face so maybe you weren't straight faced as you wrote it in the first place.
Hopefully you could see my well meaning smile with the "absolutely right" opening, but apparently that's no longer common so I can understand your confusion as https://absolutelyright.lol/ indicates Opus 4.5 has had it RLHF'd away.
The $200/month plan doesn't have limits either... once you've expended your rate limited token allowance... pay for the extra tokens out of an additional cash reserve you've set up
You're absolutely right! Limited token allowance for $200/month is actually unlimited tokens when paying for extra from a cash reserve which is also unlimited, of course.
LLMs aren't calculators; for example, your calculator always gives you the same outputs given the same inputs.
Long division is a pretty simple algorithm that you can easily and quickly relearn if needed even your LLM of choice can likely explain that to you given there's plenty of writing about it in books and on the internet.
I believe prompting an AI is more like delegation than abstraction especially considering the non-deterministic nature of the results.
Too bad they haven't done a release song since 7.3: https://www.openbsd.org/lyrics.html#73
It seems we're still collectively trying to figure out the boundaries of "delegation" versus "abstraction" which I personally don't think are the same thing, though they are certainly related and if you squint a bit you can easily argue for one or the other in many situations.
We've gotten claude code to handle 300k LOC Rust codebases, ship a week's worth of work in a day, and maintain code quality that passes expert review.
This seems more like delegation just like if one delegated a coding task to another engineer and reviewed it.
That in two years, you'll be opening python files in your IDE with about the same frequency that, today, you might open up a hex editor to read assembly (which, for most of us, is never).
This seems more like abstraction just like if one considers Python a sort of higher level layer above C and C a higher level layer above Assembly, except now the language is English.
Can it really be both?
There's a section on "why not printf" which is Standard C, but I can't find any section on "why not std::format"[1] which is Standard C++ since C++20 and works on all major compilers today in 2025.
They do mention "std::print"[2] from C++23 (which uses std::format) and compile times, but, they don't touch on "std::format" at all.
See:
[1] https://en.cppreference.com/w/cpp/utility/format/format.html
Was the website the only thing down?
This community Starlink Status page doesn't seem to show any outage: https://starlinkstatus.space/
Additionally, you can store other data for example one could have scans of important documents that are stored in Pass which means they are GPG encrypted and backed by a git repository so they are versioned and shared across multiple machines.
Greenspun's tenth rule:
Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp. -- Philip Greenspun,
Delegation is not the same as abstraction, to my understanding.
on different projects
This seems like an important caveat the author of the article failed to mention when they described this:
you can have several agents running simultaneously - one building a user interface, another writing API endpoints, and a third creating database schemas.
If these are all in the same project then there has to be some required ordering to it or you get a frontend written to make use of a backend that doesn't have the endpoints used, and you get a backend that makes use of a different database schema than the separately generated database schema.
Claude is making $72k a year for a consistent $300/day spend.
However, it won’t suggest a radically different approach unless I specifically ask it to, which I have never tried.
Assumptions without evaluation are not trustworthy.
It's "both" because if I want to interact with the SBCL REPL in SLIME I swap to the buffer for it and type in whatever I want which includes reader macros and such mentioned in the article.
* I want to apply some repetitive change across a large codebase that's just too complicated for a clever regex, bam work you literally would have never bothered to do before done in 2 minutes.
You would naively think that, as did I, but I've tested it against several big name models and they are all eventually "lazy", sometimes make unrelated changes, and worse as the context fills up.
On a small toy example they will do it flawlessly, but as you scale up to more and more code that requires repetitive changes the errors compound.
Agentic loops help the situation, but now you aren't getting it done in 2 minutes because you have to review to find out it wasn't done and then tell it to do it again N times until it's done.
Having the LLM write a program to make the changes is much more reliable.
The article mentions SBCL which is a well regarded open source Common Lisp implementation.
Common Lisp invented REPLs and the way most people use it now answers your question with "both".
A REPL usually runs locally in a subprocess or remotely through a REPL server and then your editor talks to that running Lisp Image where you can send code for compilation and recompilation while the image is running and also interact with it directly through the REPL which includes the debugger.
The GP you are referencing uses the common SLIME[0] package for anything of consequence which works exactly as described above.
I'm not the GP you asked, but distilling my own personal organization practices into the alluring "Ten Tiny Tasks" title, here's my take on it:
- Make a list of the 10 tiniest tasks with the least amount of estimated effort you can find or think of that need to be done
- Maybe save task 10 for a super quick prioritizing of the other 9 tasks, or don't because they are tiny tasks, after all
- Complete the 10 tiniest tasks
- Repeat the process until there are no more tasks (of course, there are always more tasks)