MurphyA/hacker-news huggingface dataset:
by oreally | 2026-03-11 10:14:29+00:00
> You cannot claim that a formulaic thesaurusing of a text is parody, not unless the process is related to the message of the original text itself. Even then, that's a dubious claim. Especially if it was done automatically.

Oh even if it's not a parody it would look transformed enough that a first-time reader would be getting a completely different interpretation of the story* compared to the original source. And that's all that matters.

> There aren't any mathematical observations in the output. Any math (statistics) is done in the copying process.

Wrong. Weights, which these models comprise of, are literally numbers to an extensive mathematical equation.

> It is quite literally a fuzzy way of copying.

And no one knows/there is no consensus on what a 'fuzzy way of copying' is. It is either copying or it is not. You could say that training an LLM is abstracting and integrating various text into it's weights, hereby transforming the source material and again transforming it a second time via integrating it into its weights.
by LoganDark | 2026-03-11 10:14:59+00:00
I wouldn't agree that a lack of autism diagnosis is definitive because that diagnosis is primarily based on need for treatment. (Notice how the diagnostic criteria are exclusively variations of "finds it difficult to be normal".) I only see the tokenized / scratch-blocks writing style with Aspies. (This is likely what comes off as LLM-ish to others.) Non-autistics tend to be very sloppy/imprecise in comparison. ADHD primarily has to do with behavior (misbehavior in fact) and so wouldn't solely be responsible.

I have a few friends who are definitely at other places on the spectrum and yet not diagnosed. The funny thing is Aspies are the most likely to be diagnosed because their early development can be most obvious, but it's still not always caught. (This is supported by recent research identifying the presence of a finite number of distinct genetic phenotypes in the autistic spectrum.)
by mavhc | 2026-03-11 10:15:03+00:00
He said moon first, not no Mars. And a decade to build a moon city, not to get there.

However what people say and their real reasons aren't always the same.

I assume Issacman went around to everyone and convinced them to say they're all switching on the moon, add another test flight to delay things, and in return they'll switch to using Starship in the future as they will cancel Block 1B of Artemis
by kashyapc | 2026-03-11 10:15:25+00:00
A couple of corrections (the blog-post is by colleague, but I'm not speaking for Marcin! :))

First, we do have a recent 'binutils' build[1] with test-suites in 67 minutes (it was Milk-V Megrez) in the Fedora RISC-V build system.

Second, the current fastest development machine is not Banana Pi BPI-F3. If we consider what is reasonably accessible today, it is SiFive "HiFive P550" (P550 for short) and an upcoming UltraRISC "DP1000", we have access to an eval board.

FWIW, in our FOSDEM talk earlier this year: "Fedora on RISC-V: state of the arch"[1]. It gives an overview of the hardware situation and it also has a couple of related poorman's benchmarks (an 'xz' compression test and a 'binutils' build without* the test-suite on the above two boards - that's what I could manage with the time I had).

Edit: Marcin's RISC-V test was done on StarFive "Vision Five 2". This small board has its strengths (upstreamed drivers), but it is not known for its speed!

[1] https://riscv-koji.fedoraproject.org/koji/taskinfo?taskID=91...

[2] Slides: https://fosdem.org/2026/events/attachments/SQGLW7-fedora-on-...
by hkonte | 2026-03-11 10:16:02+00:00
The lazy-load pattern is the right architecture. The missing piece is what you lazy-load still matters.

If the skill file is unstructured prose, the agent has to read the full thing before knowing what kind of instructions it contains. Typed semantic blocks (role, constraints, output_format, etc.) would let the agent assess instruction shape from a compact header before committing context to the full schema. Same difference as stuffing everything in one monolith versus named imports — named structure enables lazy loading to actually work.

Built github.com/Nyrok/flompt around this — visual builder that decomposes prompts into 12 semantic blocks and compiles to Claude-optimized XML. Same taxonomy could serve as a skill header for lazy-load pre-screening.
by imtringued | 2026-03-11 10:16:15+00:00
I don't know what bubble you are living in, but the i5-9600K is many steps up beyond "SBC class".

The Raspberry Pi 5 results on Geekbench 6 are all over the place. A score between 500 to 900 in single core and a 2000 multi core score.

Radxa 4 is an SBC based around the N100 and it basically gets the same or slightly higher performance as the Raspberry Pi 5.

Meanwhile the i5-9600K gets a score of 1677 in single core, which is 83% of the performance of the entire Raspberry Pi 5 and gets a score of 6199 when using multiple cores, that's 3x the performance.

I'd call this at least "Laptop class" and you even admitted yourself back in 2025 that you're using a processor on that level.
by hkonte | 2026-03-11 10:17:34+00:00
The bundled JS is a good read regardless of the open-source question. The interesting part is how the system prompt and instruction layers are structured internally — Anthropic uses typed, labeled sections (role, context, constraints, output format) rather than narrative prose, which tracks with their published prompting guidance.

The open-source question aside, those patterns are portable. You don't need access to the source to apply the same structure in your own agents. I built github.com/Nyrok/flompt as an open-source visual builder for exactly this — decomposes prompts into 12 semantic blocks and compiles to Claude-optimized XML. The design comes from reverse-engineering what makes Claude respond consistently vs. randomly.
by robinsonb5 | 2026-03-11 10:17:45+00:00
The point of a policy is to make a decision and then communicate that decision, so that you don't end up in a lengthy argument (or make inconsistent decisions) each time a particular situation arises.

You're right that it won't stop anyone doing harmful things with AI - all it does is codify what is and isn't considered acceptable by a project, and make it easier to justify rejections.

If a project wants to continue evaluating submissions on a case-by-base basis (and has the manpower to do it without the support of a policy) then that's entirely their choice, of course.
by znpy | 2026-03-11 10:17:49+00:00
> I practically live in Emacs and it's not slow at all. It's very zippy, and my setup isn't the lightest!

yeah, that's been my experience as well, particularly since upgrading to releases 29 and 30 where native compilation was enabled by default.

honestly the only place where it's slow it's when i'm editing terraform files, but that's because it needs to boot the terraform language server, and only on the first file of the project.
by matsemann | 2026-03-11 10:17:56+00:00
It's an Apple-user thing. It's not "my phone", it's "my iPhone". It's not my laptop, it's my MacBook. It's not my headphones, it's my AirPods. It's not my smart watch, it's my Apple Watch Ultra 3 Sapphire Gold Plated. It's not my terminal, it's the Terminal, the one to rule them all. Only plebs use non-branded terminals!
by rwmj | 2026-03-11 10:18:18+00:00
Not sure why you're being downvoted, this is very much my experience. When it matters (like, customer data is on the line) vibecoded projects are not just hilariously bad, but put you in legal danger.

We've so far found that Claude code is fine as a kind of better Coverity for uncovering memory leaks and similar. You have to check its work very carefully because about 1 time in 5 it just gets stuff wrong. It's great that it gets stuff right 4 times in 5 and produces natural code that fits into the style of the existing project, but it's nothing earth-shattering. We've had tools to detect memory leaks before.

We had someone attempt to translate one of our existing projects into Rust and the result was just wrong at a fundamental level. It did compile and pass its own tests, so if you had no idea about the problem space you might even have accepted its work.
by jeff_antseed | 2026-03-11 10:18:26+00:00
the overnight cost thing is real. "$200 in 3 days" is actually pretty tame compared to what happens when you have agents spawning sub-tasks without a budget cap.

the part that doesn't get talked about enough: most people are hitting a single provider API and treating it as fixed cost. but inference pricing varies a lot across providers for the same model. we've seen 3-5x spreads for equivalent quality on commodity models.

so half the cost problem is architectural (don't let agents spin unboundedly) and the other half is just... shopping around. not glamorous but real.
by AnssiH | 2026-03-11 10:18:44+00:00
The cross-compiler part itself is easy, but getting all the build scripting of tens of thousands of Fedora packages to work perfectly for cross-compiling would be a lot of work.

There are lots of small issues (libraries or headers not being found, wrong libraries or headers being found, build scripts trying to run the binaries they just built, wrong compiler being used, wrong flags being used, etc.) when trying to cross-compile arbitrary software.

All fixable (cross-compiling entire distributions is a thing), but a lot of work and an extra maintenance burden.
by hkonte | 2026-03-11 10:18:46+00:00
The framing of "context engineering" does most of the work here. Feeding raw notes to a model is one thing. Structuring those notes into typed semantic blocks — here is the role the model should take, here are the constraints, here is the output format — encodes judgment that isn't in the source material. The model doesn't decide what's a constraint vs. a goal vs. an example. You do.

That curation is closer to authorship than most people acknowledge. The structure IS the intellectual contribution, independent of whether the prose gets generated or hand-written.

I've been building github.com/Nyrok/flompt around this, an open-source visual prompt builder that decomposes prompts into 12 semantic blocks and compiles to Claude-optimized XML. The point isn't automation, it's making the structure explicit so it can be reasoned about and iterated.
by pm90 | 2026-03-11 10:19:37+00:00
This is amazing. While it might seem like llms are “taking away math jobs”, my perspective is that it will allow mathematicians to be much more productive.

One way to think about research is that the space of unknowns is absolutely enormous. Researchers are human and they can only focus on discovering a small part of it. There just aren’t enough people doing research! LLMs will make the existing people a lot more productive, but the space is still huuuuuge!
by hkonte | 2026-03-11 10:19:51+00:00
Parallel sessions surface a problem with prompt consistency. When you're running 4 agents simultaneously, each one's behavior depends on how well-structured its instructions are. If agent A gets a vague task description and agent B gets a typed breakdown of role/constraints/output_format, their outputs are hard to merge coherently.

The worktree approach solves the filesystem isolation but the instruction layer still matters. A structured prompt template built once and replicated across sessions produces more predictable parallel outputs than prose rephrased each time.

Built github.com/Nyrok/flompt for exactly this — visual builder that decomposes prompts into 12 semantic blocks and compiles to Claude-optimized XML. The reproducibility part is what makes it useful for parallel workflows.
by hkonte | 2026-03-11 10:20:49+00:00
The four-phase pipeline structure is the key insight here. Each phase works better when its agent gets a typed breakdown of what it's supposed to do (role, constraints, output format) rather than a narrative task description.

The problem with vague prompts across 3-6 parallel agents is phase bleed — an agent told to "implement feature X" starts making architectural decisions that belong in phase 1, or produces output in a format that phase 3 can't consume. Typed prompt structure enforces phase boundaries.

I built github.com/Nyrok/flompt around this — open-source visual builder that decomposes prompts into 12 semantic blocks and compiles to Claude-optimized XML. Useful for building reusable prompt templates for each phase of exactly the kind of pipeline you're describing.
by Brybry | 2026-03-11 10:21:02+00:00
I think a fair number of us here got into computers because of playing computer games as kids.

The issue is setting limits.

Now obviously banning is easier and lower friction but limiting to an X time per day routine can also help with self-discipline. Depends on the person.

Kids can have the same issue with TV.
I had an issue as a kid with books. My parents had to limit my reading time because I would stay up all night under my covers with a flashlight reading.
by ralferoo | 2026-03-11 10:21:16+00:00
The term eco warrior, in the UK at least, long predates social justice warrior. As the peer reply says, it's long been applied to members of Greenpeace and I think I first heard the term in the late 80s or 90s. As they said, maybe it was because of their ship Rainbow Warrior which was sunk by the French government in 1985 and prompted Greenpeace to continue the name with future boats.

I don't think it particularly had a negative connotation until recently though, to me at least it was always just someone who had strong opinions about protecting the environment, and Greenpeace always had quite a lot of support from the general population and they weren't actively disrupting the lives of ordinary citizens in the way Just Stop Oil do for instance.
by mikkupikku | 2026-03-11 10:21:18+00:00
It's plenty usable. Most of the problems with the claude TUI stem from it being a TUI (no way to query the terminal emulator's displayed character grid), so you have to maintain your own state and try to keep them in sync, which more than a few TUIs will fail at at least sometimes, hence the popularity of conventions like Ctrl+L to redraw.
by g-mork | 2026-03-11 10:21:37+00:00
This is far too simplistic, you can't discuss perf per watt unless you're talking about a job running at any decent level of utilisation. Numbers like that only matter for larger scale high utilisation services, meanwhile Intel boxes mastered the art of power efficient idle modes decades ago while almost any contemporary GPU still isn't even remotely close, and you can pick up 32 core boxes like that for pennies on the dollar.

Even if utilisation weren't a metric, "efficient" can be interpreted in so many ways as to be pointless to try and apply in the general case. I consider any model I can foist into a Lambda function "efficient" because of secondary concerns you simply cannot meaningfully address with GPU hardware at present (elasticity and manageability for example). That it burns more energy per unit output is almost meaningless to consider for any kind of workload where Lambda would be applicable.

It's the same for any edge-deployed software where "does it run on CPU?" translates to "does the general purpose user have a snowball's chance in hell of running it?", having to depend on 4GB of CUDA libraries to run a utility fundamentally changes the nature and applicability of any piece of software

A few years ago we had smaller cuts of Whisper running at something like 0.5x realtime on CPU, people struggled along anyway. Now we have Nvidia's speech model family comfortably exceeding 2x real time on older processors with far improved word error rate. Which would you prefer to deploy to an edge device? Which improves the total number of addressable users? Turns out we never needed GPUs for this problem in in the first place, the model architecture mattered all along, as did the question, "does it run on CPU?".

It's not even clear cut when discussing raw achievable performance. With a CPU-friendly speech model living in a Lambda, no GPU configuration will come close to the achievable peak throughput for the same level of investment. Got a year-long audio recording to process once a year? Slice it up and Lambda will happily chew through it at 500 or 1000x real time
by IshKebab | 2026-03-11 10:22:34+00:00
> if general-purpose HW with horribly-slow misaligned loads/stores came out from them

How is that different for RISC-V?

> I think it's a fairly reasonable expectation that all supported hardware instructions/behaviors (at least non-deprecated ones) are not slower than a software implementation

I agree! So just use misaligned loads if Zicclsm is supported. As you observed there's a feedback loop between what compilers output and what gets optimised in hardware. Since RVA23 hardware is basically non-existent at the moment you kind of have the opportunity to dictate to hardware "LLVM will use misaligned accesses on RVA23; if you make an RVA23 chip where this is horribly slow then people will laugh at you and assume it's some sort of silicon defect".
by Suliman123 | 2026-03-11 10:23:04+00:00
I have worked with tabular data for many years, and Excel has always felt heavier and more complicated than I wanted for everyday tasks. Even after decades of using it, I still run into the same friction when I just want to quickly open a table, inspect some values, or edit structured data.

At first I actually tried to recreate Excel 97 as closely as possible. I liked its simplicity and the way the interface stayed focused on the core spreadsheet workflow.

But while building it I realized that a strict clone would not really solve the problems I personally have when working with tabular data today. So the project gradually evolved into something a bit different.

Instead of copying Excel 97 exactly, I kept the ideas I liked — simplicity, clarity and speed — and then modernized the tool around my own workflow.

The result is *NextCell*, a lightweight and portable spreadsheet editor for Windows designed for quick work with tables and CSV-like data.

Current features include:

* reimagined formula system
* search and fuzzy search
* index support for faster work with structured tables
* portable build (no installation required)

The main goal of the project is to make spreadsheet editing feel lightweight again — something you can launch instantly and use without the complexity of a full office suite.

This is still an early version, but the application is already usable. I’d really appreciate feedback, especially from people who regularly work with spreadsheets, CSV files, or structured datasets.

At the moment the application runs on Windows 11. Support for MacOS and Linux is planned in the future.
by bandie91 | 2026-03-11 10:24:32+00:00
> typing on a line, backspacing all the way to the start and then typing ~ also sends a literal tilde

for the younger readers, yes, because in terminal echo mode, "backspacing" does not clear your terminal line buffer, those characters backspaced are already sent on the line. if you ever seen a misconfigured terminal, it hints what's going on, like:

user@host$ ls ~/^?^?^?^?^?~/a.out

^? is backspace's control char.

that is ssh watches what you type, not what is on the screen (terminal).
by jasode | 2026-03-11 10:24:49+00:00
>UBI is meant to provide some _basic_ income so people don't starve. It's just an optimization of welfare programs where you have a ton of bureaucracy

That's only one definition of "basic". Based on a hundred+ "UBI" threads on HN expressing different opinions, there's a wide range of what "UBI" means.

The spectrum looks something like this:

from ... <UBI just means re-allocating existing payments of welfare+foodstamps+age65socialsecurity minus wasteful costs government bureaucracies> (no new tax increases necessary)

to ... <UBI is the ideal of "nobody has to work at bullshit jobs anymore and can just pursue artistic pursuits like poetry"> (requires massive tax increases for trillions that's politically unrealistic)

For some, that means that a UBI that only provides enough money for 3 meals a day but one still has to live with 10 other roommates in a tiny communal apartment like Foxconn sweatshops in Asia is not really "basic enough". The so-called "UBI" that's still not enough to buy your own house and car and maybe a new smartphone upgrade every few years isn't the standard that some proponents are wishing for.

The "nobody has to work if they don't want to" would include some highly paid paid coders on HN who are sick and tired of working on JIRA tickets to fix bugs in boring enterprise software. This level of UBI so coders can can quit their soul-crushing white-collar job but still not reduce their standard-of-living too much ... can't be funded by removing all inefficiencies from existing welfare and food stamps payments and redistributing those "government savings" to the white-collar workers.

George Hotz is arguing that the quantity of real products like "eggs" (and by extension, cars, houses, etc) will dynamically respond to the existence UBI. These products will go down in quantity and/or become more expensive which then negates the "basic" in "basic income". The carpenters and factory line workers who previously built houses and cars don't need to work anymore because of UBI which means the supply-and-or-cost of houses and cars changes.
by dspillett | 2026-03-11 10:25:25+00:00
In situations where you have space CPU power but not spare GPU power because your GPU(s) & VRAM are allocated to be busy on other tasks, you might prefer to use what you have rather than needing to upgrade that will cost (even if that means the task will run more slowly).

If you are wanting to run this on a server to pipe the generated speech to a remote user (live, or generating it to send at some other appropriate moment) and your server resources don't have GPUs, then you either have to change your infrastructure, use CPU, or not bother.

Renting GPU access on cloud systems can be more expensive than CPU, especially if you only need GPU processing for specific occasional run tasks. Spinning up a VM to server a request then pulling it down is rarely as quick as cloud providers like to suggest in advertising, so you end up keeping things alive longer than absolutely needed meaning spot-pricing rates quoted are lower than you end up paying.
by georgehotz | 2026-03-11 10:26:27+00:00
Haha that's not what the post (or the post it links to) says. Every CS student should know there's no free lunch in search and optimization. There's tradeoffs between random search, evolutionary algorithms, and convex optimization. https://en.wikipedia.org/wiki/No_free_lunch_in_search_and_op...

There's an AI "smell" to things that are generated. Why is that? Mode collapse is impossible to see from a small number of samples. Are we mode collapsing society? How would we know if we were?

Also, will computers surpass humans has such an implicit bias in it. Have humans surpassed ants? Have ants surpassed rocks? Have jet planes surpassed teletubbies?
by rwmj | 2026-03-11 10:26:29+00:00
Neither x86-64 nor RISC-V is implemented by running each single instruction. They both recognize patterns in the code and translate those into micro-ops. On high performance chips like Rivos's (now Meta's) I doubt there'd be any difference in the amount of work done.

Code size is a benefit for x86-64 however - no one is arguing that - but you have to trade that against the difficulty of instruction decoding.
by fhennig | 2026-03-11 10:26:33+00:00
I agree with the 'setting limits' bit.

But also maybe the parent post and you refer to kids of different ages?

I didn't have access to a computer until I was 9, and then also we didn't have tables and smartphones, so there computer was only available at home as well.

I think below a certain age the limit is fine to be set as 'not at all'.