MurphyA/hacker-news huggingface dataset:
Show HN: Lettoral – Send one message, get one back. No social hack
by hayner | 2026-02-24 12:54:33+00:00
Lettoral is a web app where you send one message and receive one back from a stranger. There are no profiles, following, or likes.

I built this because I wanted a place to share those small thoughts—things that aren't big enough for social media, or something you wouldn't necessarily tell family or friends, but feel like a waste to just keep buried inside. Even if there’s no specific punchline, it’s for those moments you just want to tell someone.

Another reason was that I simply wanted to build something using vibe coding. I’m not a professional engineer. I built this strictly using Cursor, Vercel, and Supabase. (Though I did have an engineer friend give it a quick review at the very end.)

As a solo developer, I made privacy my absolute priority.
IP addresses are salted and hashed so posts cannot be linked to individuals.
Messages vanish typically 24 hours after being picked up to keep the encounter one-time and ephemeral.

It’s free to play and requires no login, so please give it a try.
I welcome any feedback, suggestions, or technical advice!
I had so much fun learning the tech for this project, and I’m genuinely curious about what professional engineers focus on or find interesting.
by alecco | 2026-02-24 12:54:37+00:00
https://archive.ph/hHdKs

Data centres seek credit ratings to unlock billions in funding for AI push

Agencies are rushing to rate the debt of projects still under construction

Data centre developers are seeking credit ratings — even while facilities are still under construction — as the tech industry tries to open up new sources of capital to fund hundreds of billions of dollars in AI investments.

S&P, Moody’s, Fitch and Kroll Bond Rating Agency have in recent months expanded their coverage to data centre projects that are yet to be completed, and in many cases given out private ratings for loans so that banks can offload them to a broader base of institutional investors.

Having the stamp of approval from rating agencies is particularly important for these colossal data centre build-outs, which have overwhelmed the project finance market and need to attract new classes of investors, such as insurance companies, that can only buy into high-grade deals rated by the big three agencies.
Show HN: SlayZone – Each card is a terminal, my record is 25 concurrent
by debuglebowski | 2026-02-24 12:55:03+00:00
I kept hitting a wall around 8 concurrent agents — not a compute problem, a working memory problem. Wrong terminal, missed input prompt, confused branches. So I built SlayZone: each kanban card hides a terminal, tasks get isolated git worktrees, and the board shows which agents are idle, working, or waiting for you. Open source. My personal record is 25 agents without losing track — curious what yours is, and what I should build next.
by prmoustache | 2026-02-24 12:56:10+00:00
I don't have that on fenec and ironfox on my pixel 6a running graphene.

What I have always had with any firefox based browser on android is erratic behavior in text field. Most of the time it works well but sometimes on some commenting systems my input is duplicated/multiplicated/garbled, trying to select where you want to insert words in the middle of the sentence sometimes becomes impossible, always resetting to the beginning of the text field, etc.

On some websites it only rarely happens, on some it is much more regular. Never understod why but when I want to edit a comment I have to resort on a regular basis to copy the full comment to a note app, edit the text, and replace it in its entirety in the text field.

Super annoying but still less annoying than using a chrome based browser with no way to remove ads and have a bit of privacy control.
by bayindirh | 2026-02-24 12:56:20+00:00
I don't use Ubuntu anywhere, so there's no actions I need to take.

> Upstream debian has been much more stable for as long as Ubuntu has existed...

Well, I use Debian before Ubuntu has existed, and it was never unstable to begin with. I understand the value of more eyes looking into something and its advantages, but let's say, Ubuntu has acted with selfish reasons towards Debian in some cases. I personally taken side in one of these debates, even.

Yes, I follow debian-devel, and even leaded a Debian derivative distro for some time.
by gverrilla | 2026-02-24 12:56:26+00:00
In Claude Code I think I can solve this with simply a rule + PreToolUse hook. The hook denies Reading the .env, and the rule sets a protocol of what not do to, and what to do instead :`$(grep KEY_NAME ~/.claude/secrets.env | cut -d= -f2-)`.

When would something like that not work?
by mexicocitinluez | 2026-02-24 12:56:36+00:00
> I chose this words because I don't think good code is nearly as expensive with coding agents as it was without them.

Still navigating this territory, but I think a lot of people are getting caught up on the idea that producing code is simply a matter of typing it at the keyboard.

One of the benefits of something like Claude Code isn't just the code it produces, but the ability to quickly try out ideas, get some feedback, AND THEN write the good code.

> than the more aesthetically pleasing

Agreed. What even is "good" code? So much of the bad code I write isn't necessarily that it's ugly, it's bad because it misses the mark. Because I made too many assumptions and didn't take the time to actual learn the domain. If I can eek out even a few more hours a week to actually build worthwhile solutions because I was able to focus a bit more, it's a win to me. My users in particular have a really difficult time imagining features without actually seeing them. They have a hard to articulating what's wrong/right without something tangible in front of them. It would be hard to argue that having the ability to quickly prototype and demo features to people is a bad thing.
by ChiMan | 2026-02-24 12:57:50+00:00
It also seems possible that clever, young outsiders will, by creatively employing AI, displace senior devs. Because unlike with law and accounting, novices in software development can generate a lot of their own reps at low cost (mostly just their time, which will be cheap compared to senior devs).

Another possibility could be using junior devs (with AI) to come up with enormous numbers of fresh ideas and minimally working programs, with the promising ones then worked on with senior devs.

Most fundamentally, because AI lowers the cost of testing out ideas and potential software products, it seems like a tool to test notions of what you should build or continue to offer customers in the first place.
by pjmlp | 2026-02-24 12:58:01+00:00
First of all, it helps to actually use a proper compiled Prolog implementation like SWI Prolog.

Second you really need to understand and fine tune cuts, and other search optimization primitives.

Finally in what concerns Game AIs, it is a mixture of algorithms and heuristics, a single paradigm language (first order logic) like Prolog, can't be a tool for all nails.
by chasd00 | 2026-02-24 12:59:37+00:00
Yeah people going on and on about peerless human generated code reminds me of that scene in iRobot when the cop asks sonny “can a robot create a work of art?” And the robot replies “can you?”. In 30 years in this industry I’ve yet seen what I would describe as perfect and maintainable code. It’s an aspirational dream not SOP.
Show HN: SNKV – SQLite's B-tree as a key-value store (C/C++ and Python bindings)
by swaminarayan | 2026-02-24 12:59:51+00:00
SQLite has six layers: SQL parser → query planner → VDBE → B-tree → pager → OS. (https://sqlite.org/arch.html)
For key-value workloads you only need the bottom three.

SNKV cuts the top three layers and talks directly to SQLite's B-tree engine.
No SQL strings. No query planner. No VM. Just put/get/delete on the same
storage core that powers SQLite.

Python:

pip install snkv

from snkv import KVStore

with KVStore("mydb.db") as db:
db["hello"] = "world"
print(db["hello"]) # b"world"

C/C++ (single-header, drop-in):

#define SNKV_IMPLEMENTATION
#include "snkv.h"

KVStore *db;
kvstore_open("mydb.db", &db, KVSTORE_JOURNAL_WAL);
kvstore_put(db, "key", 3, "value", 5);

Benchmarks vs SQLite WITHOUT ROWID (1M records, identical settings):

Sequential writes +57%
Random reads +68%
Sequential scan +90%
Random updates +72%
Random deletes +104%
Exists checks +75%
Mixed workload +84%
Bulk insert +10%

Honest tradeoffs:
- LMDB beats it on raw reads (memory-mapped)
- RocksDB beats it on write-heavy workloads (LSM-tree)
- sqlite3 CLI won't open the database (schema layer is bypassed by design)

What you get: ACID, WAL concurrency, column families, crash safety —
with less overhead for read-heavy KV workloads.
by ndriscoll | 2026-02-24 13:00:29+00:00
DNS blockers only work if the device/application is not adversarial or if you also have a smart enough firewall to block DoH, which is designed to blend in with web traffic. Once ECH is widespread, you'd likely need to MitM the device (so you need to install your CA, which is intentionally made very difficult and you might not even be able to do across all apps anymore on mobile devices?), or perhaps use DNS requests as a trigger to briefly open a default deny outbound firewall.
by menzoic | 2026-02-24 13:00:52+00:00
I work at Airbnb where I write 99% of my production code using LLMs. Spotify's CEO recently announced something similar, but I mention my employer not because my workflow is sponsored by them (many early adopters learned similar techniques), but to establish a baseline for the massive scale, reliability constraints, and code quality standards this approach has to survive.
Many engineers abandon LLMs because they run into problems almost instantly, but these problems have solutions. If you're a skeptic, please read and let me know what you think.

The top problems are:

1. Constant refactors (generated code is really bad or broken)

2. Lack of context (the model doesn’t know your codebase, libraries, APIs, etc.)

3. Poor instruction following (the model doesn’t implement what you asked for)

4. Doom loops (the model can’t fix a bug and tries random things over and over again)

5. Complexity limits (inability to modify large codebases or create complex logic)

In this article, I show how to solve each of these problems by using the LLM as a force multiplier for your own engineering decisions, rather than a random number generator for syntax.

A core part of my approach is Spec-Driven Development. I outline methods for treating the LLM like a co-worker having technical discussions about architecture and logic, and then having the model convert those decisions into a spec and working code.
by stetrain | 2026-02-24 13:00:55+00:00
> I Want to Wash My Dog. The Dog Wash Is 50 Meters Away. Should I Walk or Drive?

I dunno, that seems pretty clear to me still. Of course the answer to the question is now less obvious, since you can walk your dog to the car wash but not walk your car to the car wash.

Sure, there are alternate explanations of both sentences, but there is one simplest and most straight-forward explanation. A system that assumes an explanation that is not the most clear, and does not ask clarifying questions, has room for improvement.

If things need to be exactly stated in a structured format that leaves no ambiguity, we already have programming and query languages for that.
Show HN: BitClaw – A self-upgrading AI agent in 1,500 lines of code
by nicktikhonov | 2026-02-24 13:01:08+00:00
Hey HN!

I wanted an always-on AI agent for email, calendar, and scheduled tasks - but I didn't want to run a codebase I couldn't fully understand. So I built one small enough to read in a sitting.

I was inspired by Karpathy's post about NanoClaw, and how a smaller source code footprint leads to better security and extensibility. But even NanoClaw was harder to understand than I expected - a lot of logic for supporting multiple channels simultaneously, and it felt sluggish due to container startup time on every message. So I built an even smaller agent that keeps a single session on an always-on Docker container. It's about 4x smaller in codebase size and noticeably faster.

The architecture is deliberately boring: a single Node.js process manages a Docker container running the Claude agent SDK. Host and container communicate through atomic JSON files. No databases, no message queues.

Since the entire codebase fits in Claude's context window, the agent can modify its own source to add new capabilities — Gmail, Google Calendar, or whatever MCP server you point it at. Every source file is listed in the README with line counts, I encourage you to read it!

Would love your feedback on my approach and welcome any contributions :)
by rustyhancock | 2026-02-24 13:01:09+00:00
Fair point! I did see an extraordinary amount of music gear in akihabara and never really processed that information.

And the love and care they treat possessions with as well as the way they package second hand devices is inspiring.

It's kind of odd in a way in contrast to Kintsugi (where repair is highlighted). Almost aiming to keep things in perfect condition but then in a way celebrating repair?
by adrian_b | 2026-02-24 13:01:50+00:00
Some people prefer to know exactly what their computer does.

Thanks to Intel, who has invented the completely unnecessary System Management Mode, to compensate for the laziness of Microsoft, who could not be bothered to update MS-DOS and Windows with some features required in modern computers, now the BIOS has the ability to do whatever it wants on your computer, without this being detectable by the owner.

Hopefully the BIOS writers do not abuse this, and the many problems caused by BIOSes are due to unintentional bugs and not due to malice, but it would still better to be certain that your firmware does not do anything nefarious.

When debugging hardware problems, it is also much simpler when you are certain about what the computer really does, instead of not knowing whether the BIOS takes control when certain hardware events happen, overriding any policies that you may try to implement in your operating system.

Replacing the proprietary BIOS still does not provide complete control over what you own, as there are auxiliary CPUs with their own agenda, but it is still much closer to full control than when you do not know what the BIOS does.
OSS Tool: Hard spending limits for AI agents
by miridar | 2026-02-24 13:01:53+00:00
When building our agents and running multi-agent swarms, we ran into a problem: we couldn’t easily set separate budgets for each agent. So I built SpendGuard for our own use and figured we’d open-source it in case it helps anyone else.

It lets you create “agents” and assign each one a strict hard-limit budget in cents, with optional auto top-ups. No hosted API key is required, everything runs locally (except for the pricing list with recent models fetched from our server). The quickstart takes less than five minutes with Docker.

Happy to answer questions, take feature requests, and hear any feedback if you decide to try it.

Two pieces, both MIT:
SDK: https://github.com/cynsta/spendguard-sdk
Sidecar: https://github.com/cynsta/spendguard-sidecar
by antonios | 2026-02-24 13:02:06+00:00
Interesting, will take a look. Regarding your questions:

- Historically, reputation and web-of-trust models have been tried with mixed results (see PGP/GPG history)

- Proof of work for human validation can probably be gamed, useful as a potential workaround for rate limiting/DDOS mitigation though (check how Tor uses it)

- I'd be very skeptical providing my full KYC details to a new service, perhaps a host verification a-la Let's Encrypt could be useful as a Layer 1 "KYC" tier?
by XCSme | 2026-02-24 13:02:08+00:00
Yes. Opus could do a lot better, but fails a lot because it doesn't respect the given formatting instructions/output format.

I could modify the tests to emphasize the requirements, but then, what's the point of a test. In real life, we expect the AI to do something if we ask it, especially for agentic use-case or in n8n, because if the output is slightly wrong, the entire workflow fails.
Show HN: OpenClaw remembers for OpenClaw. Sekha remembers for your full workflow
by sekha-ai | 2026-02-24 13:02:08+00:00
OpenClaw's built-in memory is excellent—for OpenClaw. Markdown files, semantic search, survives restarts.

But it stays in OpenClaw.

I built Sekha for when you need memory that travels: OpenClaw today, Claude Code tomorrow, Kimi 2.5 or Gemini the next day. Intelligent embedding-based retrieval, persistent storage, universal API.

The difference:
OpenClaw: MEMORY.md files, internal only

Sekha: SQLite + Chroma embeddings, REST/MCP/SDKs, any LLM via LiteLLM/OpenRouter

Use case: OpenClaw explores a codebase, stores findings in Sekha via MCP. Next day, Claude Code reads the same context via SDK. Your analytics pipeline queries it via REST. Same memory, any tool, any model.

Others add memory to OpenClaw. Sekha frees your memory from OpenClaw.

Stack: Rust (fast), SQLite (durable), Chroma (search), LLM-Bridge for universal routing. AGPL, self-hosted.

GitHub: https://github.com/sekha-ai/sekha-controller | Site: https://sekha.dev

The question: What would you build if your AI memory worked with every tool, not just one?
Show HN: WebPerceptor – Enabling AI Mediated Web Browsing
by theartofhci | 2026-02-24 13:02:27+00:00
Ok. Here's an idea. Using LLMs we automatically modify all of the web in real time as we browse.

No more pesky copy/paste, trigger buttons or overlay windows.

When you open a web page all of the text is just automatically sent to and modified by an LLM with some prompt and then automatically re-inserted into the web page as it loads.

WebPerceptor is an client-side Chromium plugin I've made to experience such a web.

Trailer: https://youtu.be/MPSisruuTY0?si=EYMvGXiQvF_wud3S
by veunes | 2026-02-24 13:02:29+00:00
Spot on about keeping that AGENTS.md and logging all decisions. Letting an agent code for a long stretch without pinning down the state is a surefire way to end up with a Frankenstein codebase. Forcing it to document why you ditched LinuxKPI and went native basically saved the project. It's kinda ironic that AI is making us enforce strict project documentation - the exact thing human devs never have time for
Show HN: CtxVault – Local memory control layer for multi-agent AI systems
by FiloVenturini | 2026-02-24 13:02:30+00:00
I built CtxVault while working on multi-agent systems and persistent memory patterns.

Most agent architectures treat memory as a retrieval problem. Multiple agents share a vector store and rely on metadata filtering, routing logic, or prompt-level rules to control what each agent can see.

In practice, this becomes hard to reason about as systems grow.

Moreover, I found that memory in agent systems is not just storage. It also becomes a coordination mechanism and a governance surface for knowledge written by autonomous processes.

CtxVault explores a different abstraction.

Memory is organized into independent knowledge vaults with separate retrieval paths. Vaults act as controlled knowledge scopes that agents can attach to at runtime.

The server exposes vault names as part of the API design. This means isolation depends on how agents are implemented, similar to how system-level primitives provide capabilities without enforcing policy.

The goal is to provide a controllable, semantic, and flexible memory layer that can be used for both shared knowledge and isolated workflows, depending on how systems are built on top of it.

Vaults can be inspected and managed manually. Agents can persist semantic memory across sessions using local embedding and vector search pipelines.

The system runs fully local using FastAPI as a control layer.

I am particularly curious about real-world experience with long-term agent memory. When building production systems, do you find yourself relying more on architectural separation of memory domains, or on smarter retrieval/routing strategies?

GitHub:
https://github.com/Filippo-Venturini/ctxvault
by drooby | 2026-02-24 13:02:41+00:00
I'm currently in the hiring process.. and my head is spinning..
1. Interviewing is becoming more difficult. Many skills we valued two years ago are genuinely becoming less valuable. 2. The skills we tested 2 years ago were in-part a proxy for evaluating critical think and systems thinking skills. So we need to re-evaluate our technical interview process. 3. It's genuinely less friction for me to prompt Claude than some of my SEII colleagues. And wtf - Claude is getting so good that it's starting to feel like it's outpacing the intellectual competency of some people. Sure - it does weird things like add Sleep instead of proper concurrency. SEIIs did that too, and we couldn't as easily reprogram them with Skill.md 4. Core competencies remain necessary. Systems thinking. SOLID principles. Communication skills. These skills are more important than ever. 5. Companies that offshored engineers and traded core competency for perceived-throughput are doing the same calculus with Claude. 6. Core business models are threatened. There is fear that revenue streams will dry up. How does one hedge against that risk? Humans are expensive. 7. Navigating this situation is hard and uncertain
Show HN: Lila-E8 – 40M Parameter LLM with 0.37 Loss via E8 Lattice Attention
by bootstraptor | 2026-02-24 13:03:05+00:00
I’m excited to release Sovereign-Lila-E8, a novel transformer architecture that replaces standard attention mechanisms with a native E8 Root System Lattice.
While the industry is brute-forcing intelligence with trillions of parameters, I went "outside" the system to find a zero-viscosity solution.

I built Sovereign-Lila-E8 because I wanted to see if we could bypass the 'viscosity' of standard attention mechanisms using higher-dimensional geometry.

Most small models today are just distilled copies of larger ones. LILA-E8 is different: it implements a native E8 Root System Lattice directly into the attention weights. By using the densest sphere packing in 8 dimensions, we minimize semantic friction (information loss) in the latent space.

The Results:

Efficiency: 40M parameters achieving 0.37 Train / 0.44 Val Loss on the TinyStories dataset (outperforming standard 60M baselines).
Stability: Sustained coherence for 1000+ tokens without the common semantic looping seen in small-scale transformers.
By implementing the E8 exceptional Lie algebra directly into the attention weights, I’ve achieved a state of "Geometric Resonance" that standard transformers simply cannot reach.
At 200,000 steps, the model achieved a state of 'Geometric Resonance'—a phase shift in quality that typically requires 2-3x more parameters in standard architectures.
I’ve provided a 1-click Google Colab for instant verification of the weights and generation quality.
GitHub: https://github.com/SPUTNIKAI/sovereign-lila-e8
Colab: https://colab.research.google.com/github/SPUTNIKAI/sovereign...
Zenodo: (Preprint): https://zenodo.org/records/18731736

Looking for feedback on expanding the context window to 4096 and potentially porting this to the 24D Leech Lattice. (see also https://zenodo.org/records/18729723 )
by Kuinox | 2026-02-24 13:03:06+00:00
Were the middle class, but what people think of middle class today, doesn't apply to what it was back then.

> The bourgeoisie are a class of business owners, merchants and wealthy people, in general, which emerged in the Late Middle Ages, originally as a " middle class" between the peasantry and aristocracy. They are traditionally contrasted with the proletariat by their wealth, political power, and education, as well as their access to and control of cultural, social, and financial capital.

https://en.wikipedia.org/wiki/Bourgeoisie

Today the meaning of bourgeoisie, still applies to "business owners, merchants and wealthy people", but is now seen as upper class.