MurphyA/hacker-news huggingface dataset:
by lqstuart | 2026-02-22 05:54:58+00:00
I think I read it's more "hillbilly" English that sounds like Shakespeare? Like coal mining towns where words like "deer" and "bear" are two syllables. Probably a combination of that and eastern seaboard.

I only learned recently that the vowel shift and non-rhotic R's in Britain happened after the colonization of America. Americans still talk "normally" whereas the English got weird. Also why Irish accents sound closer to American than British I think. Linguistics is cool
by wazHFsRy | 2026-02-22 05:57:54+00:00
Absolutely. And you can also always let the agent look back at the plan to check if it is still on track and aligned.

One step I added, that works great for me, is letting it write (api-level) tests after planning and before implementation. Then I’ll do a deep review and annotation of these tests and tweak them until everything is just right.
by m463 | 2026-02-22 05:58:25+00:00
It's really simple.

1 Kg of hydrogen is SUPER EXPENSIVE (equivalent ~ 1 gallon of gas)

$17/gallong when I looked at the pumps

When the Mirai first came out, owners didn't care because the fuel was free.

But after that ended, they had to buy it for themselves.

who wants to pay that?

(also, stations weren't plentiful like EV chargers, and even though you could fill up faster than an EV charge, who cares when you can't go very far (distance-wise from home).
by abalone | 2026-02-22 05:58:57+00:00
Honestly I wonder how much of this type of post is polluting HN. Sure, you can make things with the assistance of LLMs, but to be frank there is next to nothing added by this post.

"You can be effective if you have an unlimited token budget." I mean, come on.

I just got done diagnosing the CloudFlare outage as potentially overtrusting an LLM dev workflow.
by basch | 2026-02-22 06:01:27+00:00
Honesty this is just language models in general at the moment, and not just coding.

It’s the same reason adding a thinking step works.

You want to write a paper, you have it form a thesis and structure first. (In this one you might be better off asking for 20 and seeing if any of them are any good.) You want to research something, first you add gathering and filtering steps before synthesis.

Adding smarter words or telling it to be deeper does work by slightly repositioning where your query ends up in space.

Asking for the final product first right off the bat leads to repetitive verbose word salad. It just starts to loop back in on itself. Which is why temperature was a thing in the first place, and leads me to believe they’ve turned the temp down a bit to try and be more accurate. Add some randomness and variability to your prompts to compensate.
by Aurornis | 2026-02-22 06:02:01+00:00
> No cuBLAS means they wrote their own GEMM kernels, which is a massive undertaking

Not to diminish the impressiveness of this overall project, but it says right up front that these were vibe coded and the Opus 4.6 co-author lines are right in the commit messages. Those pieces were adapted from existing work via LLM, which is exactly the right use in a proof of concept project like this.
by manmal | 2026-02-22 06:03:02+00:00
I don’t think this is a result of the base training data („the internet“). It’s a post training behavior, created during reinforcement learning. Codex has a totally different behavior in that regard. Codex reads per default a lot of potentially relevant files before it goes and writes files.

Maybe you remember that, without reinforcement learning, the models of 2019 just completed the sentences you gave them. There were no tool calls like reading files. Tool calling behavior is company specific and highly tuned to their harnesses. How often they call a tool, is not part of the base training data.
by sleight42 | 2026-02-22 06:03:16+00:00
Sure but the GPUs are fairly anemic, right? I get that they have more Gpu-addressable memory from the shared pool.

I have a 10900K with 65GB RAN and a 3090 24GB VRAM lying around gathering dust. 24GB isn't as much as a Mac but my cores run a whole lot faster. I may be able to run a 34B 4bit quantized model in that. Granted, the mofo will eat a lot of power.
by jcgrillo | 2026-02-22 06:03:22+00:00
If an AI agent ever became as productive at writing code as a well-organized 20 person engineering team you'd still need to run it for a year or more to replicate any nontrivial SaaS product.

And the thing about many of these products isn't their feature set, it's their stability. It's their uptime. It's how they handle scaling invisibly and with no effort on your part. These are things you can't just write down from whole cloth, they are properties that emerge over time by adapting the the reality of scale. Coding isn't the whole deal, and your 20x clanker which can do nothing but re-arrange text in interesting patterns is going to have some trouble with the realities of taking that PoC to production. You'll still need experienced, capable people for that. And lots of time.

A lot of this "ermahgerd everything will change" drivel is based on some magical fundamentally new technology emerging in the near future that can do things that LLMs cannot do. But as far as anyone knows, that future may be never.

So even given a large improvement in agentic coding I'm not convinced it really changes the build vs buy equation much.
by scuff3d | 2026-02-22 06:03:56+00:00
You've missed the point. This isn't engineering, it's gambling.

You could take the exact same documents, prompts, and whatever other bullshit, run it on the exact same agent backed by the exact same model, and get different results every single time. Just like you can roll dice the exact same way on the exact same table and you'll get two totally different results. People are doing their best to constrain that behavior by layering stuff on top, but the foundational tech is flawed (or at least ill suited for this use case).

That's not to say that AI isn't helpful. It certainly is. But when you are basically begging your tools to please do what you want with magic incantations, we've lost the fucking plot somewhere.
by throwaway7783 | 2026-02-22 06:05:32+00:00
I have to give this a try. My current model for backend is the same as how author does frontend iteration. My friend does the research-plan-edit-implement loop, and there is no real difference between the quality of what I do and what he does. But I do like this just for how it serves as documentation of the thought process across AI/human, and can be added to version control. Instead of humans reviewing PRs, perhaps humans can review the research/plan document.

On the PR review front, I give Claude the ticket number and the branch (or PR) and ask it to review for correctness, bugs and design consistency. The prompt is always roughly the same for every PR. It does a very good job there too.

Modelwise, Opus 4.6 is scary good!
by selridge | 2026-02-22 06:05:35+00:00
I really have no idea. There's almost no good mapping from conversation to code. Take e.g. https://github.com/Protonk/PAWL

There's...thousands of conversations in dozens of different configurations over months to make that. What...out of that do you want to know? What do you deserve to know by dint of my making a submission?

Those aren't rhetorical. I think if you can answer those two, that's a fair start. Good luck lol.
by computomatic | 2026-02-22 06:06:07+00:00
If I say “you are our domain expert for X, plan this task out in great detail” to a human engineer when delegating a task, 9 times out of 10 they will do a more thorough job. It’s not that this is voodoo that unlocks some secret part of their brain. It simply establishes my expectations and they act accordingly.

To the extent that LLMs mimic human behaviour, it shouldn’t be a surprise that setting clear expectations works there too.
by corndoge | 2026-02-22 06:07:20+00:00
I still don't understand what openclaw is or does and i've read the docs multiple times over.

"Any OS gateway for AI agents across WhatsApp, Telegram, Discord, iMessage, and more.
Send a message, get an agent response from your pocket. Plugins add Mattermost and more."

"What is OpenClaw?

OpenClaw is a self-hosted gateway that connects your favorite chat apps — WhatsApp, Telegram, Discord, iMessage, and more — to AI coding agents like Pi. You run a single Gateway process on your own machine (or a server), and it becomes the bridge between your messaging apps and an always-available AI assistant."

https://docs.openclaw.ai

My best interpretation of this is that it connects an BYO agent to your messenger client of choice. I don't understand the hype. I already have apps that allow me to message the model server running on my home lab. The model server handles tool calls (ie it is "agentic"). It has RAG over a dataset with a vector search for query. What is new about openclaw? I would like to understand it but what i see people say and what is in the docs do not seem compatible. Anyone have a resource?
by rramadass | 2026-02-22 06:09:45+00:00
You missed the point.

The idea is to protect oneself by using various techniques of deception/reflexive control through stratagems like "poisoning the well", "borrow a knife", "misdirect/misinform" etc. to present different contradictory information/personas/overload-data to "The System" thus obfuscating/masking reality.

You mess-up the raw data and then use reflexive control techniques to allow them to draw inferences from a set that you have predetermined.

Technology, mass commoditized and given easy access to, is central here and should be spearheaded by the organizations i mentioned due to their reputation cachet eg; Tor/Tails/Proxies/Vpns/Secure OSes/Protocols/etc. Simultaneously they should also push for legislation for stricter govt. control over data usage/companies eg. GDPR/etc.

The populace also needs to educate themselves on techniques of Propaganda/Manipulation by reading the works of the authors i mentioned earlier. This will sharpen their critical thinking skills which is a must-have today.

Palantir is very much in the vein of Cambridge Analytica except that they have expanded vastly on its theme and gained "legitimacy". People need to study all about CA and then extrapolate it to today's AI capabilities if they want to understand the shape of things to come.

Some References:

Deception: The Invisible War Between the KGB and the CIA by Edward Jay Epstein; For history/ideas/themes/motivation for further study on a complex subject.

Propaganda: The Formation of Men's Attitudes by Jacques Ellul - https://en.wikipedia.org/wiki/Propaganda:_The_Formation_of_M...

Reflexive Control - https://en.wikipedia.org/wiki/Reflexive_control
by swe_dima | 2026-02-22 06:11:20+00:00
Since everyone is showing their flow, here's mine:

* create a feature-name.md file in a gitignored folder

* start the file by giving the business context

* describe a high-level implementation and user flows

* describe database structure changes (I find it important not to leave it for interpretation)

* ask Claude to inspect the feature and review if for coherence, while answering its questions I ask to augment feature-name.md file with the answers

* enter Claude's plan mode and provide that feature-name.md file

* at this point it's detailed enough that rarely any corrections from me are needed
by MrJohz | 2026-02-22 06:11:21+00:00
Patching the DOM existed long before React, that wasn't a new technique. IIRC, the idea was more that the VDOM helped by making batching easier and reducing layout thrashing, where you write to the DOM (scheduling an asynchronous layout update), read from the DOM (forcing that thenlayout update to be executed synchronously now).

That said, none of that is specific to the VDOM, and I think a lot of the impression that "VDOM = go fast" comes from very early marketing that was later removed. I think also people understand that the VDOM is a lightweight, quick-to-generate version of the DOM, and then assume that the VDOM therefore makes things fast, but forget about (or don't understand) the patching part of React, which is also necessary if you've got a VDOM and which is slow.
by Merad | 2026-02-22 06:13:08+00:00
I've been working off and on on a vibe coded FP language and transpiler - mostly just to get more experience with Claude Code and see how it handles complex real world projects. I've settled on a very similar flow, though I use three documents: plan, context, task list. Multiple rounds of iteration when planning a feature. After completion, have a clean session do an audit to confirm that everything was implemented per the design. Then I have both Claude and CodeRabbit do code review passes before I finally do manual review. VERY heavy emphasis on tests, the project currently has 2x more test code than application code. So far it works surprisingly well. Example planning docs below -

https://github.com/mbcrawfo/vibefun/tree/main/.claude/archiv...
Show HN: Threatmodeling Tool to outgrow spreadsheets, word and MS-TMT
by Rana_KV | 2026-02-22 06:13:37+00:00
Built a threat modeling app with architecture diagrams, threat/evaluation workflows, and risk report exports. This is meant to redefine the threat modeling experience.

Still improving it and very open to blunt feedback on usability, security, and what’s missing for real team workflows.
by zahlman | 2026-02-22 06:13:53+00:00
> After Claude writes the plan, I open it in my editor and add inline notes directly into the document. These notes correct assumptions, reject approaches, add constraints, or provide domain knowledge that Claude doesn’t have.

This is the part that seems most novel compared to what I've heard suggested before. And I have to admit I'm a bit skeptical. Would it not be better to modify what Claude has written directly, to make it correct, rather than adding the corrections as separate notes (and expecting future Claude to parse out which parts were past Claude and which parts were the operator, and handle the feedback graciously)?

At least, it seems like the intent is to do all of this in the same session, such that Claude has the context of the entire back-and-forth updating the plan. But that seems a bit unpleasant; I would think the file is there specifically to preserve context between sessions.
by jaggederest | 2026-02-22 06:14:52+00:00
I haven't worked significantly with lean but I'm toying with my own dependently typed language. generally you only have to construct a proof once, much like a type or function, and then you reuse it. Also, depending on the language there are rewriting semantics ("elaboration") that let you do mathematical transformations to make two statements equivalent and then reuse the standardized proof.
by tanelpoder | 2026-02-22 06:15:31+00:00
The issue in the enterprise (SAN) storage space is that there are so many layers where things can go wrong. Lost writes due to the OS kernel (like the fsyncgate), in-kernel storage interaction drivers, the storage array software itself, then disk firmware etc. Theoretically you could read back the just-written block and check if it’s what you wrote, but maybe it’s returned from some cache, before the bug happened.

Another scenario (OS, driver bugs) is that a correct block is written to a wrong location. Yes the write is persisted, but overwriting a wrong location. So now you have two incorrect blocks.
by colinrand | 2026-02-22 06:15:49+00:00
I like this direction, but I don't think the crypto angle is necessary or practical in an enterprise / corporate setting. Current audit and compliance frameworks don't leverage or really recognize or encourage cryptographically based proof of action, so I don't see the agentic world as needing this to drive agentic adoption.

However, everything else you lay out is spot on.
by throwaway13337 | 2026-02-22 06:15:52+00:00
That's right. And don't forget that the chips it runs on are manufactured by companies I might not agree with. Nor the mining companies that got the metal. Nor the energy company that powers it.

The wonderful thing about markets that work is that you can swap things out without being under their boot.

I worry about a LLM duopology. But as long as open weight models are nipping at their heels, it is the consumer that stands to benefit.

The train we're on means a lot of tech companies will feel a creative destruction sort of pain. They might want to stop it but are forced by the market to participate.

Remember that Google sat on their AI tech before being forced to productize it by OpenAI.

In a working market, companies are forced to give consumers what they want.
by al_borland | 2026-02-22 06:15:54+00:00
From the FAQ:

How are stories ranked?

The basic algorithm divides points by a power of the time since a story was submitted. Comments in threads are ranked the same way.

Other factors affecting rank include user flags, anti-abuse software, software which demotes overheated discussions, account or site weighting, and moderator action.

—-

Personally, I appreciate that the rankings are done at a site level, and there isn’t a bunch of tracking and manipulation to give me a personal “feed” to drive engagement. A lot of comments on this site complain about those practices on other sites. I don’t think it’s welcome here.
by iamnothere | 2026-02-22 06:16:56+00:00
Exactly, DuskOS is for maintaining a somewhat degraded level of civilization and perhaps rebuilding, while salvaged machines are still common. CollapseOS is there if things get even worse, to retain a minimal level of computing capability during the transition to whatever comes next. It’s hard to imagine the need for CollapseOS while things are still working, but in some horrible future where it’s the only system keeping the water system running, people will appreciate it.
Show HN: HashTrade – Open-source LLM trading agent with episodic memory
by mertozbas | 2026-02-22 06:17:49+00:00
I built HashTrade — an open-source autonomous trading agent that treats an LLM as a non-parametric decision function conditioned on episodic memory, rather than encoding strategy as code.

The core idea: instead of writing if/else trading logic, you give an LLM three tools (exchange access, memory, UI control) and let it form strategy through accumulated experience. The agent wakes on a variable 5→10→20→25 min cycle, reads its past notes, fetches market data, reasons about what to do, and optionally executes trades. Every decision and outcome is logged to an append-only JSONL file that becomes its long-term memory.

Technical details:

- Built on Strands Agents (AWS) with CCXT for 100+ exchange support
- 3 tools only: use_ccxt (28 actions — market data, orders, arbitrage detection), history (persistent memory), interface (dynamic UI)
- Variable-interval scheduler to avoid detectable timing patterns in order flow
- Fire-and-forget WebSocket streaming for sub-second dashboard latency
- Supports Claude, GPT-4o, Ollama (local), and Bedrock — auto-detected
- PWA frontend in vanilla JS, no framework dependencies
- Client-side credential isolation — API keys never leave the browser
- Recursive credential redaction prevents keys from leaking into LLM context

The interesting emergent behavior: early wake cycles are conservative ("observing BTC at $67k, noting support level"). After a few days of accumulated memory, the agent starts referencing its own past observations to form trading theses ("last 3 times we saw this pattern, price bounced — going long"). The policy improves not through fine-tuning but through growing context.

I wrote a paper formalizing this as a Memory-Conditioned Markov Decision Process if anyone's interested in the theory: the key insight is that the effective policy is non-stationary even with fixed model parameters, because the growing memory changes the attention distribution at each step.

Setup: pip install hashtrade && hashtrade

Live demo at hashtrade.ai, code at github.com/mertozbas/hashtrade. Apache 2.0.

Would love feedback on the architecture — especially the tradeoff between soft risk constraints (enforced via system prompt) vs. hard tool-level enforcement.
by rustyhancock | 2026-02-22 06:18:12+00:00
Edit: reading the below it looks like I'm quite wrong here but I've left the comment...

The single transistor multiply is intriguing.

Id assume they are layers of FMA operating in the log domain.

But everything tells me that would be too noisy and error prone to work.

On the other hand my mind is completely biased to the digital world.

If they stay in the log domain and use a resistor network for multiplication, and the transistor is just exponentiating for the addition that seems genuinely ingenious.

Mulling it over, actually the noise probably doesn't matter. It'll average to 0.

It's essentially compute and memory baked together.

I don't know much about the area of research so can't tell if it's innovative but it does seem compelling!
by Hello9999901 | 2026-02-22 06:18:36+00:00
This would be a very interesting future. I can imagine Gemma 5 Mini running locally on hardware, or a hard-coded "AI core" like an ALU or media processor that supports particular encoding mechanisms like H.264, AV1, etc.

Other than the obvious costs (but Taalas seems to be bringing back the structured ASIC era so costs shouldn't be that low [1]), I'm curious why this isn't getting much attention from larger companies. Of course, this wouldn't be useful for training models but as the models further improve, I can totally see this inside fully local + ultrafast + ultra efficient processors.

[1] https://en.wikipedia.org/wiki/Structured_ASIC_platform
by dredmorbius | 2026-02-22 06:18:38+00:00
MCP: Model Complex Protocol.

Which is an AI/LLM thing: "an open standard and open-source framework introduced by Anthropic in November 2024 to standardize the way artificial intelligence (AI) systems like large language models (LLMs) integrate and share data with external tools, systems, and data sources" (Wikipedia).

<https://modelcontextprotocol.io/docs/getting-started/intro>

<https://en.wikipedia.org/wiki/Model_Context_Protocol>
by alephnerd | 2026-02-22 06:18:42+00:00
The main primary sources I'd say are:

1. "Occidentosis: A Plague from the West" by Jalal Al-e-Ahmad

2. "Red Shi'ism vs. Black Shi'ism" by Ali Shariati

3. "Martyrdom: Arise and Bear Witness" by Ali Shariati

4. "The Purification of the Soul" by Ahmed Fardid

Most modern Iranian Shia philosophy is largely a synthesis of Heiddiger and Muhammad Iqbal ("Saare Jahan Se Aacha, Hindustan Humara"), as these Iranian philosophers were largely from Khorasan and Dari speaking so most were acquaintances with Iqbal, who popularized Heiddiger's thought across Persianate society.

Basically, if you synthesize Heidigger's concept of authenticity with the Persianate motif of martyrdom with a dose of Persianate chauvinism and Shia theology, you have what became Khomeinism.

It's basically Maoism but with the Marxist-Leninist and Confucian undertones replaced with Shia and Persianate undertones.

I also can't help but notice how both Mao/Li/Chen and Shariati/Fardid/Al-e-Ahmad were all members of the rural elite who faced dislocation when immigrating to urban society in the early 20th century.

Edit: can't reply

> Are there specific translations you’d call out

We had English translations published by the Iranian government at Widener Library [0]. There might be similar ones online. Idk, I don't want to get on a list.

> Wait, is this Farsi? I think I can parse it with my rough knowledge of Hindi

Muhammad Iqbal was both an Indian freedom fighter, the creator of the Pakistan movement, and one of the first modern Persianate scholars.

Back during that era, most Persian scholarship was centered amongst the South Asian community. Additionally, educated Koshur and Paharis (irrespective of religion) from that era were heavily Persianate in outlook (eg. Even Koshur Hindus back then would consider studying a BA Persian as an alternative to a BA Sanskrit).

As such, Iqbal's works were very common amongst the madrassa-turned-western educated Iranian intelligentsia of the early 20th century.

[0] - https://library.harvard.edu/collections/middle-eastern-colle...