Hacker Newsnew | past | comments | ask | show | jobs | submit | rootnod3's commentslogin

Really? That’s the takeaway?

Sure, CPU wise an old phone can do the same job, but not the GPIO.

But hey, thanks AI delusion , even a fucking raspberry pi is now a purchase I gotta think 3 times about before pulling the trigger.


If y’all can’t cope without Claude, y’all need Jesus. There’s the “can boost my productivity “ and then there’s the “Claude takes the wheel and my brain is off”.

AGENTS.md on a standard protocol. Sorry but no. You either understand the thing or you don’t.

It’s a chat protocol. Something that is supposed to be very private and secure. Seeing an AGENT.md file is a huge turn-off there, sorry to say. Feel free to burn my karma down to oblivion.


I'd actually feel pretty safe with a LLM project if spec'd against the protocol documentation as opposed to a rookie's handcoded implementation. If security is the concern, I don't think using random reimplements is very safe to begin with.

I'd actually feel pretty safe with a LLM project

Same. I had a couple LLM's rewrite, harden an anonymous image board. It's not popular but exposed to the internet and the Tor network. Not worried at all.


This is a false choice. You can pick neither and for all you know you're picking both.

Unless the model changes and messes half the code base on next iteration. Or Anthropic decides to A/B test your agent.

Or when shit goes sideways and someone actually needs to take a human look at the BF s. I’d rather have the guy who manually with human eyes read the specs.


> Something that is supposed to be very private and secure

Not sure how using an LLM for development of the tool has any affect on this. From a security perspective, I think that would've had more validity a year or two ago, but these days, I'd argue LLMs practice better security in generated code on average than a normal developer.

From the privacy angle, I have no idea how having an AGENTS.md (for development purposes) has any impact on privacy.

I don't want to "burn [your] karma to the ground", I just want to understand this angle, because I'm not sure I see how it applies.


Do you not use AI for coding?

> Do you not use AI for coding?

A lot of people prefer to understand the things they ship. I don't understand why this remains surprising to some.


Indeed, Linus Torvalds is infamous for not caring what he ships (https://news.ycombinator.com/item?id=50111350). That's why he's never been known to go on, let's say impassioned tirades against people who submit bad patches to the linux kernel. After all, it's not like he's ever apologized for inflammatory behavior before (https://news.ycombinator.com/item?id=18000698).

On a more serious note, it's not a dichotomy that one either uses AI to code or they care about what they ship. Some people use AI to code and care what they ship.


Linus, like anyone else, has been wrong about things before, I'm not really interested in the appeal to authority here.

Two simple facts:

    1. Reading & understanding code takes longer than writing it the first time.
    2. Caring about what you ship requires *understanding* what you ship.
Therefore

    Using LLMs to write code cannot save you time, because it takes longer to understand what it has written than it would to write it in the first place.
That leaves simple changes like refactorings as the main use of LLMs in responsible development. Hardly a massive accelerator.

Point 1 is dependent on the individual and often not the case. Especially in cases where the part that takes effort is figuring out the poorly documented syntax/api you’re stuck with for the task (extra fun with new components iterating rapidly and pinning the next version requires new scaffolding), you can read the invocation and the accompanying couple of lines of test code way faster than you’d mould them yourself. Which also translates neatly to point 2 (how efficiently can you in many cases ascertain the outcome of smearing the chosen bits on the cpu with easily digestible tests).

Also the emotionally laden appeal to "responsibility" is weak, as it glosses over the many cases where overspending resources on creating the thing would be the irresponsible choice.


> Point 1 is dependent on the individual and often not the case.

Not really. To properly understand code you must have a mental model of what it is doing. You need that model whether you are reading or writing the code. It is easier to build that model while writing the code than while simply reading it. To build the model while reading the code requires having the same understanding of the problem and the same approach already in mind, which is almost never the case for any moderately complex problem.

> Especially in cases where the part that takes effort is figuring out the poorly documented syntax/api you’re stuck with for the task

Reading LLM generated code does not avoid this, and in fact it is often worse since LLM comments are terrible at getting to the point.


> I'm not really interested in the appeal to authority here.

Citing Linus isn't an appeal to authority, it's an example. A prominent example, but no one is saying to follow what he does or what he believes.


> Some people use AI to code and care what they ship.

The vast, vast majority of people using LLMs to build software don't care at all about quality. I'll grant you Torvalds, but he's very much not the norm (and he's wrong: by the time you review the code the model wrote, you spent as much time reviewing it as you would've writing it, so no time was saved).


Believe it or not, some people actually know how to write code, and <shock horror> understand what it fucking does too!

I will never understand software dev's obsession with LLM generated slop. Compare it with the response from the likes of professional authors, artists.

I've said it before I'll say it again: a computer generating shit en masse for you is great if you don't know how to do it yourself, and don't care what the result is.


The security comes from E2EE - which happens in the clients not the server

That only works because the clockmaker had the manual experience to begin with and only needs to remember to get back into the groove. If however he had always only worked with CNC machines the story would be very different.

I'm not convinced that's true. If you have experience driving an automatic car with lane assist, you'll have an easier time driving a 1980s manual car than somebody with no driving experience at all.

Likewise, the machinist still knows the principles of construction even if he's only used CNC machines. The endoscopist still knows the principles of colonoscopy even if he's only done it with AI assistance.

Just anecdotally, back when I took courses in assembler and logic circuits, there seemed to be no great difference in success between people like myself that had previous experience with that, and people who'd at most done some high-level scripting.

If you have enough curiosity I doubt using AI will be a roadblock to true understanding, just like high-level programming languages weren't.


> If you have enough curiosity

That’s a gigantic “if”. Anything can become a positive in the right hands, but we have to consider the societal impact of broadly available tools.


Same. That is why I am over in a corner happily coding away with Common Lisp and McCLIM to write myself an editor that mixes ACME UI with Lisp. Is it ultra-polished? Hell no. But it definitely keeps me sane and I know what I wrote.

Nice, Acme is underrated and needs more experimentation/adaptation as a concept.

Only on the UI part though. I wanted a Genera/CLIM approach, so having that filesystem thing sitting there felt wrong. But I did like the “all UI is text” approach. And with CLIM presentations it can go very far.

No, book was published 2008.

yeah, no shit. i have a copy. if you care to read the actual link it's about an update this month, october 2026.

Company selling shovels for the gold rush claims they are close to making the largest and bestest shovel. News at 11.


Came here to look for M8 mentions. That firmware is just pure magic.


And, for those who missed it, Dirtywave M8 has recently been made available on iOS as a $30 app.


I have 3 M8s (2 v1, 1 v2) but they are not with me 100% of the time so the iOS version has been an absolute blessing. Tim is a coding powerhouse.


If Ubuntu offers LTS and is catering to business it is very much open to criticism. They can take it or leave it, but anyone is entitled to an opinion about it.


I mean....insert Linux distro of any kind. Yes, hardware support is good, but most distros are otherwise pretty awful in many other regards now.


To pre-empt any replies: yes, I absolutely prefer BSDs over Linux any day. But even those are flawed and I really think we missed the Symbolics golden era. THAT would be the age of "own and live in the system". OpenBSD gets closest there. At least the codebase is hackable enough.

Linux went off the fucking rails. What the fuck is that over engineered yes command?!

Edit: https://github.com/coreutils/coreutils/blob/master/src/yes.c

270 loc for a tool that prints "y" in a loop. WTF?!

Meanwhile this exists: https://github.com/openbsd/src/blob/master/usr.bin/yes/yes.c


The rationale is explained in this 2015 commit: https://github.com/coreutils/coreutils/commit/35217221c211f3...

The current implementation is much faster than in that commit on GNU/Linux, as documented in this 2026 commit: https://github.com/coreutils/coreutils/commit/2b1c059e6a06ee...

The OpenBSD implementation is much slower than both the GNU versions from 2015 and 2026. However, their goals are different from ours, and that statement should not be interpreted as criticism of theirs.


The 99% use case is for just `yes` though. That is optimized for such a niche corner-case...


What downsides does it have for end users?


It makes the code way less auditable and more prone to bugs and errors. Or let the kernel change its paging mechanism and now your fucking “yes” tool needs an update to be “efficient”. The tool has one job…print yes or another word you give it. It by definition does not have to optimized to oblivion. Same goes for echo.

It’s arsinine to optimize it to that level instead of just keeping it readable and maintainable. And portable.

The gnu version is 100% not easily portable because it has assumptions about the underlying kernel.


> It by definition does not have to optimized to oblivion. Same goes for echo.

I don't know about oblivion, and non-portable optimizations are not good. But perhaps yes(1) and echo(1) are among the tightest inner loops of scripting. You would not want them to bottleneck the pipeline. You'd want them pumping output faster than it could be accepted or written out.

Perhaps there is an opportunity for a /dev/yes, which acts like /dev/zero, only it continually outputs whatever filename it was opened as (good luck!)


I think NetBSD and OpenBSD do just fine with the simple version. Or maybe they write better scripts :)

The current implementation works on any system with read and write system calls.

The Linux optimization just uses splice and vmsplice. If those APIs are changed to avoid zero-copy, as was considered for some time after the AF_ALG security issues, it is unlikely that another API would take their place. So, no, I do not think it needs any changes if Linux changes.


What can go wrong with allocating memory based on user input….I wonder….


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: