MurphyA/hacker-news huggingface dataset:
by DSMan195276 | 2026-02-09 06:32:24+00:00
Something that bothers me here is that Anthropic claimed in their blog post that the Linux kernel could boot on x86 - is this not actually true then? They just made that part up?

It seemed pretty unambiguous to me from the blog post that they were saying the kernel could boot on all three arch's, but clearly that's not true unless they did some serious hand-waving with kernel config options. Looking closer in the repo they only show a claimed Linux boot for RISC-V, so...

[0]: https://www.anthropic.com/engineering/building-c-compiler - "build a bootable Linux 6.9 on x86, ARM, and RISC-V."

[1]: https://github.com/anthropics/claudes-c-compiler/blob/main/B... - only shows a test of RISC-V
by raincole | 2026-02-09 06:33:40+00:00
No, she can't.

The process to amend the constitution of Japan [0]:

1. two thirds of the house

2. two thirds of the senate

3. referendum

LDP just won the house. IF all LDP house representatives agreed with Takaichi then she could pass the first stage. Only two left!

[0]: https://ja.wikipedia.org/wiki/%E6%97%A5%E6%9C%AC%E5%9B%BD%E6...
by kachapopopow | 2026-02-09 06:34:04+00:00
They should have gone one step further and also optimized for query performance (without editing the source code).

I have cough AI generated an x86 to x86 compiler (takes x86 in, replaces arbitrary instructions with functions and spits x86 out), at first it was horrible, but letting it work for 2 more days it was actually close to only 50% to 60% slowdown when every memory read instruction was replaced.

Now that's when people should get scared. But it's also reasonable to assume that CCC will look closer to GCC at that point, maybe influenced by other compilers as well. Tell it to write an arm compiler and it will never succeed (probably, maybe can use an intermeriadry and shove it into LLVM and it'll work, but at that point it is no longer a "C" compiler).
by fc417fc802 | 2026-02-09 06:34:29+00:00
> I mentioned it because some people ...

I may well have been one of those people in a previous exchange. I argue that IP law only protects people as a means to an end. As a severe restriction of individual freedoms, I firmly believe that its only legitimate purpose can be the net benefit of society as a whole. If any given aspect of IP law (including copyright) is no longer required to encourage innovation then it should be abolished.

All of that is perfectly consistent with the ideal of rewarding people for the full transitive value of their work which itself follows naturally from the goal of incentivizing innovation.

Regarding the plane, I apologize if my tone tended towards quibbling. I understood and agree with the point you were trying to make about income inequality. Private jets constitute an almost absurd level of physical resource allocation to the individual. Jet engines alone require significant quantities of rhenium, an element that's slightly rarer than platinum. I don't really see how any of that relates to copyright or AI though.
by codexetreme | 2026-02-09 06:34:47+00:00
one of the biggest hurdles I see still, is that the red tape around this is so massive, it takes away a lot of the valuable time of actually working on something for your startup.

Take me for example, I spend nearly 3 4 days worth of efforts each month following up on different websites, and with agents of so called "compliance management companies"

I just hope they did something that solves this and makes it very easy to do corporate compliance.
by threethirtytwo | 2026-02-09 06:35:04+00:00
The truth is that it’s lowering the difficulty of work people used to consider hard. Which parts get easier depends on the role, but the change is already here.

A lot of people are lying to themselves. Programming is in the middle of a structural shift, and anyone whose job is to write software is exposed to it. If your self-worth is tied to being good at this, the instinct to minimize what’s happening is understandable. It’s still denial.

The systems improve month to month. That’s observable. Most of the skepticism I see comes from shallow exposure, old models, or secondhand opinions. If your mental model is based on where things were a year ago, you’re arguing with a version that no longer exists.

This isn’t a hype wave. I’m a software engineer. I care about rigor, about taste, about the things engineers like to believe distinguish serious work. I don’t gain from this shift. If anything, it erodes the value of skills I spent years building. That doesn’t change the outcome.

The evidence isn’t online chatter. It’s sitting down and doing the work. Entire applications can be produced this way now. The role changes whether people are ready to admit it or not. Debating the reality of it at this point mostly signals distance from the practice itself.
by Alupis | 2026-02-09 06:35:12+00:00
I'm reminded, once again, of the recent "vibe coded" OCaml fiasco[1].

The PR author had zero understanding why their entirely LLM-generated contribution was viewed so suspiciously.

The article validates a significant point: it is one thing to have passing tests and be able to produce output that resembles correctness - however it's something entirely different for that output to be good and maintainable.

[1] https://github.com/ocaml/ocaml/pull/14369
by kristiandupont | 2026-02-09 06:36:07+00:00
I don't feel that I see this anywhere but if so, I guess I'm in a third camp.

I am "pro" in the sense that I believe that LLM's are making traditional programming obsolete. In fact there isn't any doubt in my mind.

However, I am "anti" in the sense that I am not excited or happy about it at all! And I certainly don't encourage anyone to throw money at accelerating that process.
by TheDong | 2026-02-09 06:36:35+00:00
Civilization is about cooperating with your fellow man to build great things, not bowing to the feudal lord Apple Inc.

A truly civilized person would use Linux, OpenBSD, etc, a free operating system where they may contribute fixes for their fellow man without having to beg at the boots of the single richest company on the planet with radar numbers asking for fixes from on high.
by o175 | 2026-02-09 06:36:49+00:00
The supply chain concern is fair but it's worth noting Electron ships an entire Chromium — that's a way bigger CVE surface than Tauri's dependency tree. Not saying Tauri is automatically safer, just that it's not a clean win either way.

The architecture here is the important part though. Keeping all the crypto in the Rust backend and treating the webview as an untrusted render layer is exactly right. Even if someone slips something into a frontend dependency, they can't get at plaintext because the decryption never happens in JS. Tauri v2's new ACL permission model helps too — you can lock down which commands the webview is even allowed to call.

If you want to make the supply chain story more concrete, `cargo-vet` would be a nice addition. It's Mozilla's tool for auditing crate dependencies and would directly answer the "how do I trust all this Rust code" question.
by cable2600 | 2026-02-09 06:37:15+00:00
Memory and Chip prices went up, and Microsoft is building Data Centers. Copilot 365 only has 3% of users using the AI features. Microsoft's biggest AI customer, OpenAI is looking to use other Data Centers. Microsoft's stock took a 10% hit and lost $400B USD. Microsoft's Data Centers have high electricity bills and thus have a 0 ROI. If Microsoft doesn't get customers for its AI Data Centers, they stand to lose more than $400B USD. Investors want to see profits, not broken promises of profits.
by threethirtytwo | 2026-02-09 06:37:18+00:00
Stop repeating this trope. It can spit out something you've never built before this is utterly clear and demonstrated and no longer really up for debate.

Claude code has never been built before claude code. Yet all of claude is being built by claude code.

Why are people clinging to these useless trivial examples and using it to degrade AI? Like literally in front of our very eyes it can build things that aren't just "embarrassingly solved"

I'm a SWE. I wish this stuff wasn't real. But it is. I'm not going off hype. I'm going what I do with AI day to day.
Show HN: Logifai – Auto-capture dev logs for AI coding assistants
by TomoyaFujita | 2026-02-09 06:37:39+00:00
The idea is simple: pipe your command through logifai, and Claude Code can search your logs directly.

npm run dev 2>&1 | logifai
Hit an error → just ask Claude "what went wrong?"
It captures everything into structured NDJSON, has a Web UI with live streaming, auto-redacts secrets, and includes a Claude Code Skill so Claude can search your logs without you ever copy-pasting terminal output.

It also has a Log Reference feature — select lines in the Web UI, click "Copy Ref", paste a compact logifai:// URI into Claude instead of hundreds of log lines. Keeps your context window clean.

It solves what I found to be the biggest pain point: the manual copy-paste shuttle between terminal and Claude Code.

Feedback and contributions welcome!

https://github.com/tomoyaf/logifai
by LegionMammal978 | 2026-02-09 06:37:48+00:00
Thank you for that information, all I could find on the website was that "The source code of the Mizar verifier and accompanying tools is available to the members of SUM" [0], which of course does not reflect the newer status quo.

> Mizar is indeed "scarcely advertised", but all the information is publicly available, who wants to know knows.

Yes, there indeed seems to be a good bit of information available, especially about the library and its articles. But some parts seem to be scattered about, unless you already know where to look, or know someone who knows. Perhaps it's a matter of taste.

(For comparison, I've recently been dabbling a fair bit with Metamath: it's not really advertised outside of its small circle these days, but the website does a good job at introducing the system, while also offering a complete reference in the form of the Metamath book. From there, the primary challenges to a new user are the fiddly tooling, the cryptic labeling scheme, and the puzzling DV conditions.)

[0] https://mizar.uwb.edu.pl/system/
by acjohnson55 | 2026-02-09 06:38:00+00:00
> If you are really truly reviewing every single line in a way that it is the same as if you hand wrote it… just hand write it.

I think this is only true for people who are already experts in the codebase. If you know it inside-out, sure, you can simply handwrite it. But if not, the code writing is a small portion of the work.

I used to describe it as this task will take 2 days of code archaeology, but result in a +20/-20 change. Or much longer, if you are brand new to the codebase. This is where the AI systems excel, in my experience.

If the output is +20/-20, then there's a pretty good chance it nailed the existing patterns. If it wrote a bunch more code, then it probably deserves deeper scrutiny.

In my experience, the models are getting better and better at doing the right thing. But maybe this is also because I'm working in a codebase where there are many example patterns in the codebase to slot into and the entire team is investing heavily in the agent instructions and skills, and the tooling.
by yosefk | 2026-02-09 06:38:04+00:00
"Ironically, among the four stages, the compiler (translation to assembly) is the most approachable one for an AI to build. It is mostly about pattern matching and rule application: take C constructs and map them to assembly patterns.

The assembler is harder than it looks. It needs to know the exact binary encoding of every instruction for the target architecture. x86-64 alone has thousands of instruction variants with complex encoding rules (REX prefixes, ModR/M bytes, SIB bytes, displacement sizes). Getting even one bit wrong means the CPU will do something completely unexpected.

The linker is arguably the hardest. It has to handle relocations, symbol resolution across multiple object files, different section types, position-independent code, thread-local storage, dynamic linking and format-specific details of ELF binaries. The Linux kernel linker script alone is hundreds of lines of layout directives that the linker must get exactly right."

I worked on compilers, assemblers and linkers and this is almost exactly backwards
by anupamchugh | 2026-02-09 06:39:50+00:00
This is correct if the prompt is single-use. It's wrong if the prompt becomes a reusable skill that fires correctly 200 times.

The problem isn't generation — it's unstructured generation. Prompting ad-hoc and hoping the
output holds up. That fails, obviously.

200 skills later: skills are prose instructions matched by description, not slash commands. The thinking happens when you write the skill. The generation happens when you invoke it. That's
composition, not improvisation. Plus drift detection that catches when a skill's behavior diverges
from its intent.

Don't stop generating. Start composing.
by deevus | 2026-02-09 06:40:34+00:00
I've been working on an offline cross-platform application currently called Dev Cleaner.

> Dev Cleaner is a desktop application for scanning and cleaning development cache files and build artifacts. It helps developers reclaim disk space by identifying and safely removing caches like node_modules, .cargo/registry, .npm, and other build artifacts.

It's closed source, as I am planning to sell a license. But if you email me, I am happy to provide a build.
by kristopolous | 2026-02-09 06:40:49+00:00
Thanks. Really wish I had known about this. I wanted his commentary on an article I mentioned him in from 2022

I would have paid serious money to have gotten that

This is the article btw https://siliconfolklore.com/internet-history

Here's the one other large project I've got at that domain
https://siliconfolklore.com/scale/

It for a history talk in 2024. I worked months on that
by AnthonyMouse | 2026-02-09 06:40:50+00:00
Whether AI training in general is fair use and whether an AI that spits out a verbatim copy of something from the training data has produced an infringing copy are two different questions.

If there is some copyrighted art in the background in a scene from a movie, maybe that's fair use. If you take a high resolution copy of the movie, extract only the art from the background and want to start distributing that on its own, what do you expect then?
by anupamchugh | 2026-02-09 06:40:58+00:00
This is exactly right. Before agents, you could hide architectural debt behind manual heroics — a
senior dev holds the system in their head, patches around the rot.

Agents can't hold tribal memory. They read your manifest, your specs. If foundations are
composable (few flexible tools over many specific ones), agents chain through cleanly. If they're
messy, agents amplify the mess at machine speed.

The hard part didn't get harder. It got visible. The fix is infrastructure: workspace manifests,
typed boundaries with lifecycle tracking, drift detection that catches stale specs before they
break a workflow.
by TheDong | 2026-02-09 06:41:07+00:00
If the debian maintainers don't align with your preferences you can:

1. Create your own apt repository with newer software, and install from that. It's easy to package things, you can share the repository with trusted friends, running linux with friends is fun.

2. You can switch to a distro, like NixOS or Arch, which values up-to-date software more than slow stable updates.

Debian does seem to be more aligned with mailservers and such, where updates can be slow and thoughtful, not as much with personal ai development boxes where you want the hot new ai tool of the week available asap.

... Either way, learning to package software correctly for your distro of choice is a good idea, it's fun to bang out a nix expression or debian package when you need to install something that's not available yet.
by Ygg2 | 2026-02-09 06:41:29+00:00
First off Alpha Evolve isn't an LLM. No more than a human is a kidney.

Second depends. If you told them to pretrain for writing C compiler however long it takes, I could see a smaller team doing it in a week or two. Keep in mind LLMs pretrain on all OSS including GCC.

> Meanwhile, at every step of the way these things become better and better.

Will they? Or do they just ingest more data and compute?[1] Again, time will tell. But to me this seems more like speed-running into an Idiocracy scenario than a revolution.

I think this will turn out another driverless car situation where last 1% needs 99% of the time. And while it might happen eventually it's going to take extremely long time.

[1] Because we don't have much more computing jumps left, nor will future data be as clean as now.
by jrflowers | 2026-02-09 06:41:31+00:00
It seems like if Anthropic released a super cool and useful _free_ utility (like a compiler, for example) that was better than existing counterparts or solved a problem that hadn’t been solved before[0] and just casually said “Here is this awesome thing that you should use every day. By the way our language model made this.” it would be incredible advertising for them.

But they instead made a blog post about how it would cost you twenty thousand dollars to recreate a piece of software that they do not, with a straight face, actually recommend that you use in any capacity beyond as a toy.

[0] I am categorically not talking about anything AI related or anything that is directly a part of their sales funnel. I am talking about a piece of software that just efficiently does something useful. GCC is an example, Everything by voidtools is an example, Wireshark is an example, etc. Claude is not an example.
by throwaway81523 | 2026-02-09 06:42:08+00:00
The video tape law was created basically a reaction to someone finding out and revealing Robert Bork (then a SCOTUS nominee)'s video rentals. The rentals themselves were bland, featuring stuff like Disney films, but I guess Congress got scared. It passed by wide margins at the time. I wonder if they are still scared the same way.

Background: https://en.wikipedia.org/wiki/Video_Privacy_Protection_Act
by kromio | 2026-02-09 06:42:36+00:00
yo, so i've been playing around with plugin.new recently - it's this no-code wordpress plugin thing. honestly, it's pretty neat. the ai actually gets what you're asking for and gives you clean code. and the github integration is actually useful, not just a gimmick. you can actually build and develop a plugin over time, not just do a one-off thing. what do you guys think about this approach? anyone else mess around with no-code plugin tools like this?
by lubujackson | 2026-02-09 06:43:13+00:00
I'm on the "higher level of abstraction" side, but that seems to be very much at odds with however Anthropic is defining it. Abstraction is supposed to give you better high-level clarity at the expense of low-level detail. These $20,000 burning, Gas Town-style orchestration matrices do anything but simplify high level concerns. In fact, they seem committed building extremely complex, low-level harnesses of testing and validation and looping cycles around agents upon agents to avoid actually trying to deal with whatever specific problem they are trying to solve.

How do you solve a problem you refuse to define explicitly? We end up with these Goodhart's Law solutions: they hit all of the required goals and declare victory, but completely fail in every reasonable metric that matters. Which I guess is an approach you make when you are selling agents by the token, but I don't see why anyone else is enamored with this approach.
by whateverboat | 2026-02-09 06:43:21+00:00
You are missing the big picture.
> The only thing it does is make setting up a new computer marginally easier for one specific case (ie. you want to install a non-windows operating system AND you don't want to dualboot), and ticks off a box for being "vendor agnostic" or whatever.

this is much more important than you realize.
by anupamchugh | 2026-02-09 06:43:25+00:00
Building my dev workspace into an operating system. Not metaphorically — structurally.

10 MCP servers as device drivers (exchange APIs, browser automation, Apple docs, issue tracking).
200+ skills as prose runbooks that compose system calls. Agent-mail for IPC between parallel
agents. A drift detector called "wobble" that scores skill stability using bias/variance analysis.
by TheDong | 2026-02-09 06:43:44+00:00
There are some real differences.

All the homebrew packages have checksums and are versioned in git, so if the upstream website is compromised and a malware installer is put in place of the package, `curl | bash` will just install the malware, while `brew` would start erroring out and refuse to install after downloading something with a different checksum.

You also get an audit log in the form of the git repo, and you also ensure everyone's downloading the same file, since `curl | bash` could serve different scripts to different IPs or user-agents.

I don't think brew does proper build sandboxing, so like `./configure.sh` could still download some random thing from the internet that could change, so it's only a bit better.

If you want proper sandboxing and thus even more security, consider nix.
by Flatterer3544 | 2026-02-09 06:44:15+00:00
This standstill mostly started happening when the capitalism took hold too deep and wide, look at Sweden and its golden age that lasted until all the restrictions on capitalism were silently removed.

While capitalism is a good model, it needs to be kept balanced, restricted..

Shareholder primacy is ruining everything, too much influence in politics from too many external sources.
by Ygg2 | 2026-02-09 06:44:26+00:00
You can be wrong on every step of your approximation and still be right in the aggregate. E.g. order of magnitude estimate, where every step is wrong but mistakes cancel out.

Human crews on Mars is just as far fetched as it ever was. Maybe even farther due to Starlink trying to achieve Kessler syndrome by 2050.
by stlee42 | 2026-02-09 06:45:26+00:00
Exactly this. Linker is threading given blocks together with fixups for position-independent code - this can be called rule application. Assembler is pattern matching.

This explanation confused me too:

Each individual iteration: around 4x slower (register spilling)
Cache pressure: around 2-3x additional penalty (instructions do not fit in L1/L2 cache)
Combined over a billion iterations: 158,000x total slowdown

If each iteration is X percent slower, then a billion iterations will also be X percent slower. I wonder what is actually going on.
by o175 | 2026-02-09 06:45:37+00:00
The 158,000x slowdown on SQLite is the number that matters here, not whether it can parse C correctly. Parsing is the solved problem — every CS undergrad writes a recursive descent parser. The interesting (and hard) parts of a compiler are register allocation, instruction selection, and optimization passes, and those are exactly where this falls apart.

That said, I think the framing of "CCC vs GCC" is wrong. GCC has had thousands of engineer-years poured into it. The actually impressive thing is that an LLM produced a compiler at all that handles enough of C to compile non-trivial programs. Even a terrible one. Five years ago that would've been unthinkable.

The goalpost everyone should be watching isn't "can it match GCC" — it's whether the next iteration closes that 158,000x gap to, say, 100x. If it does, that tells you something real about the trajectory.
by Lockal | 2026-02-09 06:45:45+00:00
Certified HN garbage. AI slop article trending for last 24 hours. Low quality discussion, which requires no entrance knowledge.

What about article? <Well known fact> + "nobody talks about" is fire title, really. People will vote for it even without reading the article.

Also: short sentences. For emphasis. Always three.

Feel the same pain as me? Find me on X or LinkedIn, or join the discussion on Hacker News.