MurphyA/hacker-news huggingface dataset:
by the_harpia_io | 2026-02-16 15:08:25+00:00
I think the issue is everyone's stuck in the same boat - the alternative to using AI and spending time reviewing is just writing it yourself, which takes even longer. so even if it's not a net win, it's still better than nothing. plus a lot of companies aren't actually measuring the review overhead properly - they see 'AI wrote 500 lines in 2 minutes' and call it a productivity win without tracking the 3 hours spent debugging it later. the inefficiency doesn't get competed out because everyone has the same constraints and most aren't measuring it honestly
by K0balt | 2026-02-16 15:08:36+00:00
To be fair, we all have holes in our reasoning if we don’t carefully consider things and sometimes they are very surprising when they come to light. The dependency issue (need the car at the car wash) is an easy one that often trips up people at first glance too. (Left my phone at work, plan: take an uber to get to the office, walk to the couch and remember I don’t have my phone to call an uber)

Things like that are notorious points of failure in human reasoning. It’s not surprising that machines based on human behavior exhibit that trait as well, it would be surprising if they didn’t.
by 999900000999 | 2026-02-16 15:08:43+00:00
Everything should remain absolutely private until after conviction.

And only released if it's in the public interest. I'd be very very strict here.

I'm a bit weird here though. I basically think the criminal justice system is very harsh.

Except when it comes to driving. With driving, at least in America, our laws are a joke. You can have multiple at fault accidents and keep your license.

DUI, keep your license.

Run into someone because watching Football is more important than operating a giant vehicle, whatever you might get a ticket.

I'd be quick to strip licenses over accidents and if you drive without a license and hit someone it's mandatory jail time. No exceptions.

By far the most dangerous thing in most American cities is driving. One clown on fan duel while he should be focusing on driving can instantly ruin dozens of lives.

But we treat driving as this sacred right. Why are car immobilizers even a thing?

No, you can not safely operate a vehicle. Go buy a bike.
by conradev | 2026-02-16 15:09:21+00:00
Peter has been prolific and talented long before AI tools. I became familiar with his work a decade ago: https://github.com/steipete/PSTCollectionView

People seem to think that because we all have the same tools and because they’re increasingly agentic, that the person wielding the tool has become less relevant, or that the code itself has become less relevant.

That is just not the case, at least yet, and Peter is applying a decade plus of entrepreneurial and engineering experience.
by bri3d | 2026-02-16 15:09:22+00:00
It’s better in some dimensions and not others, and it’s built on a fundamentally different architecture, so of course they use both.

Ghidra excels because it is extremely abstract, so new processors can be added at will and automatically have a decompiler, control flow tracing, mostly working assembler, and emulation.

IDA excels because it has been developed for a gazillion years against patterns found in common binaries and has an extremely fast, ergonomic UI and an awesome debugger.

For UI driven reversing against anything that runs on an OS I generally prefer IDA, for anything below that I’m 50/50 on Ghidra, and for anything where IDA doesn’t have a decompiler, Ghidra wins by default.

For plugin development or automated reversing (even pre LLMs, stuff like pattern matching scripts or little evaluators) Ghidra offers a ton of power since you can basically execute the underlying program using PCode, but the APIs are clunky and until recently you really needed to be using Java.
by palata | 2026-02-16 15:09:30+00:00
Taking the opportunity to ask: are there nice recommended resources for a beginner to start with reverse engineering (ideally using Ghidra)? Let's say for an experienced developer, but not so experienced in reverse engineering?

I guess one issue I have is that I don't have good ideas of fun projects, and that's probably something I need to actually get the motivation to learn. I can find a "hello world", that's easy, but it won't help me get an idea of what I could reverse engineer in my life.

For instance I have a smartspeaker that I would like to hack (being able to run my own software on it, for fun), but I don't know if it is a good candidate for reverse engineering... I guess I would first need to find a security flaw in order to access the OS? Or flash my own OS (hoping that it's a Linux running there), but then I would probably want to extract binary blobs that work with the buttons and the actual speaker?
by noisebrain | 2026-02-16 15:09:34+00:00
I've used ChatGPT

Response:

Definitely by car

Even if it’s only 50 meters away, the whole point of a car wash is to wash the car, so taking it there on foot would be… complicated (and suspicious to the neighbors).

Now, seriously:

Distance: 50 meters is basically next door.

Time: by car it will literally take 10–15 seconds.

Effort: minimal.

Logic: the car needs to be there to be washed, so you have to drive it anyway.

The only reason to walk would be if you first want to check whether there’s a line or availability, and then come back for the car.

Pro tip:
If you see it’s empty, take advantage immediately. Car washes tend to fill up quickly around midday.

Is it just an exterior wash, or interior as well?
by 13pixels | 2026-02-16 15:09:39+00:00
Distinguishing 'AI Research' (crawling) from 'AI Referral' (user clicks) is the hardest part. Most agents (OAI-SearchBot, ClaudeBot) declare themselves in UA, but the actual click-through often strips the referrer or shows as direct/none. We've had some luck correlating 'time of crawl' with 'time of visit' to fingerprint AI traffic, but it's noisy.

Self-hosted is definitely the way to go for raw logs though. GA4 obfuscates too much of this.
by the_harpia_io | 2026-02-16 15:09:57+00:00
I mean in theory yes, good abstractions solve a lot - but in practice you're rarely starting from a clean slate. you're integrating with third-party APIs that have weird edge cases, working with legacy code that wasn't designed for what you're doing now, dealing with requirements that change mid-implementation. even with great abstractions the real world bleeds through. and AI doesn't know which abstractions are 'right' for your specific context, it just pattern-matches what looks reasonable. so you end up reviewing not just for bugs but to make sure it's not subtly incompatible with your architecture
by victoreum | 2026-02-16 15:09:59+00:00
I built Billiver because most useful financial data is locked behind
expensive paywalls, even though it all comes from public SEC filings.

It covers 3,000+ US public companies. No signup required.

Some things that are hard to find elsewhere for free:

- Debt maturity schedules (when each company's debt comes due)
- Revenue breakdowns by business segment and geography
- Supply chain relationships between companies
- Insider cluster buying detection (3+ insiders buying within 30 days)
- Institutional investor portfolios (13F filings)
- Piotroski F-Score and Altman Z-Score screening

Built with Next.js, Supabase, and Cloudflare Workers.
All data sourced from SEC EDGAR (10-K, 10-Q, 13F filings).

What financial data do you wish was easier to access?
by evanelias | 2026-02-16 15:10:07+00:00
This sounds conceptually similar to performance_schema [1] in MySQL or MariaDB, which is a built-in feature originally introduced in MySQL 5.5 (2010). Or perhaps the easier-to-use sys schema [2], which wraps performance_schema among other things, introduced in MySQL 5.7 (2015).

It's great to have that observability functionality, but I don't really understand the purpose of writing a new DBMS from scratch to add this though. Why not get something merged into Postgres core?

[1] https://dev.mysql.com/doc/refman/8.4/en/performance-schema.h...

[2] https://dev.mysql.com/doc/refman/8.4/en/sys-schema.html
by 13pixels | 2026-02-16 15:10:38+00:00
This is a great dataset. The 'cross-domain causality leap' is something we see constantly in brand monitoring—e.g. an LLM seeing a pricing page for 'Product A' and a feature list for 'Product B' and confidently asserting 'Product A has Feature B for $X'.

One edge case you might want to add: *Temporal Merging*. We often see models take a '2024 Roadmap' and a '2023 Release Note' and halluncinate that the roadmap features were released in 2023. It's valid syntax, valid entities, but impossible chronology.

Are you planning to expand this to RAG-specific failures (where the context retrieval causes the mix-up) or focusing purely on model-internal logic gaps?
by g-mork | 2026-02-16 15:10:42+00:00
Confused what to make of the comments here. Access to court lists has always been free and open, it's just a pain in the ass to work with. The lists contain nothing much of value beyond the names involved in a case and the type of hearing

It's not easy to see who to believe. The MP introducing it claiming there is a "cover up" is just what MPs do. Of course it makes him look bad, a service he oversaw the introduction of is being withdrawn. The rebuttal by the company essentially denies everything. Simultaneously it's important to notice the government are working on a replacement system of their own.

I think this is a non-event. If you really want to read the court lists you already can, and without paying a company for the privilege. It sounds like HMCTS want to internalise this behaviour by providing a better centralised service themselves, and meanwhile all the fuss appears to be from a company operated by an ex-newspaper editor who just had its only income stream built around preferential access to court data cut off.

As for the openness of court data itself, wake me in another 800 years when present day norms have permeated the courts. Complaining about this aspect just shows a misunderstanding of the (arguably necessary) realities of the legal system.
by ryanmcl | 2026-02-16 15:11:17+00:00
Interesting concept, but I'm skeptical about the passport verification solving the core problem.

The issue isn't just proving you're human - it's proving you're a unique human without creating a honeypot of identity data. Hashing name+DOB+country+last4digits helps, but state actors (as you mention) can absolutely rainbow-table this. And if a government wants to run influence ops, they'll just use real passports from real people (employees, contractors, or bought credentials).

The bigger challenge: even if you verify I'm human, how do you stop me from being paid to post propaganda? A verified human account spreading misinformation is arguably more dangerous than a bot, because now it carries the "verified human" trust signal.

I think the real solution is less about identity verification and more about social graph trust + transparent provenance. If I can see that an account was created 5 years ago, has genuine engagement patterns, and is vouched for by people I trust, that's more meaningful than "this person scanned a passport."
That said, I respect the attempt to tackle this. The bot problem is real and getting worse fast. Just not convinced passport verification is the moat you think it is.

What's your plan for preventing paid human accounts from gaming the system?
Show HN: API router that picks the cheapest model that fits each query
by robinbanner | 2026-02-16 15:11:25+00:00
I got frustrated paying $60/M tokens for reasoning queries when a $0.80/M model gives comparable results for most of them. So I built Komilion — a model router that classifies each API request and routes it to a cheaper model that fits.

- Drop-in replacement for the OpenAI SDK (change one line: base_url)
- Each query gets classified (regex fast path + lightweight LLM classifier) and matched against ~390 models
- Three tiers (Frugal/Balanced/Premium) to control the quality-cost tradeoff
- Automatic failover if a provider goes down
- Cost metadata in every response

The routing logic is benchmark-driven (LMArena, Artificial Analysis), not ML-based — simpler to debug and reason about. The regex fast path handles ~60% of requests in under 5ms with zero API calls.

Example: a customer support bot doing 10K conversations/month went from ~$250/mo (everything pinned to Opus 4.6) to ~$40/mo with routing. Most conversations were FAQ-level questions that a smaller model handled fine.

Stack: Next.js, Vercel, Neon PostgreSQL, OpenRouter upstream. Hosting cost: ~$20/month.

We ran a head-to-head benchmark: same 15 prompts through Opus, GPT-4o, Gemini Pro, and the router. Simple tasks cost 66% less with routing. Complex tasks produced 2x more detailed output because the router picked specialized models per task type. Full data: https://dev.to/robinbanner/we-benchmarked-4-ai-api-strategie...

Architecture writeup: https://dev.to/robinbanner/inside-komilions-architecture-how... — there's a free tier if you want to try it.
by newsclues | 2026-02-16 15:11:29+00:00
If you prohibit the punishment of minors, you create an incentive for criminals to exploit minors.

Why are we protecting criminals, just because they are minors? Protect victims, not criminals.

Unfortunately reputational damage is part of the punishment (I have a criminal record), but maybe it's moronic to create a class of people who can avoid meaningful punishment for crimes?
by the_harpia_io | 2026-02-16 15:11:34+00:00
yeah test-driven constraints help a lot - we've been moving that direction too, basically treating the agent like a junior dev who needs guard rails. the build+test gates catch the obvious stuff. but the trickier part is when tests pass but the code still isn't what you wanted - like it works but takes a fundamentally wrong approach, or adds unnecessary complexity. those are harder to catch with automation. re: LLM vs AI terminology - fair point, though I think the ship has sailed on general usage. most people just say AI to mean 'the thing that writes code' regardless of what's under the hood
by robinbanner | 2026-02-16 15:11:36+00:00
Backstory: I was building a customer support AI for a client last year. We started with Claude Opus for everything because it worked great. The bill was $250/month for maybe 10K conversations.

Then I looked at the actual queries. 70% were things like "what are your hours?" and "how do I return something?" — questions where a $0.80/M-token model gives the same answer as a $15/M-token model. But about 5% were genuinely complex (multi-step troubleshooting, product comparisons requiring reasoning) where Opus was noticeably better.

I started manually routing: simple patterns to a cheap model, everything else to Opus. The bill dropped to $40/month with no quality complaints from users. But maintaining the routing logic across projects got tedious — every new app needed the same classification + model selection + failover logic.

So I built Komilion to package it up. The classification runs in two stages:

1. A regex fast path catches ~60% of requests instantly (greetings, FAQ patterns, simple classification tasks). Zero API calls, under 5ms.

2. For the rest, a lightweight LLM classifier determines task type and complexity, then matches against a routing table built from LMArena and Artificial Analysis benchmark data.

What surprised me in the benchmark data: complex tasks through the router actually produced MORE detailed output than any single pinned model (6,614 chars avg vs 3,573 for Opus). The router selects specialized models per task type rather than using a generalist model for everything.

Stack: Next.js on Vercel, Neon PostgreSQL, OpenRouter upstream. Total hosting cost ~$20/month. It's a solo project.

The thing I'd do differently: I should have started with the benchmark data instead of building the product first. The numbers make the case better than any feature list.

Happy to answer technical questions about the routing logic, benchmark methodology, or anything else.
by djkurlander | 2026-02-16 15:11:56+00:00
Though strong passwords or preferably ssh keys are important, there will always be servers with weak passwords.

And DO doesn’t have to side with individual abuse reporters. If they cared, they could spend a fraction of an hour setting up the knock-knock software on one of their own servers, and generate their own list of abusive IPs. They just don’t care.
by WarmWash | 2026-02-16 15:12:20+00:00
>But it’s quite simple to see LLMs are quite far still from being human.

At this point I think it's a fair bet that whatever supersedes humans in intelligence, likely will not be human like. I think that their is this baked-in assumption that AGI only comes in human flavor, which I believe is almost certainly not the case.

To make an loose analogy, a bird looks at a drone an scoffs at it's inability to fly quietly or perch on a branch.
by WorldMaker | 2026-02-16 15:12:35+00:00
The animated film was said to be a side-by-side project from different budgets (WB Animation versus The CW/WB Television Studios).

I think at this point JMS is trying to keep a diverse income and still do comics as well as TV projects. Even during Sense8, with its Netflix-sized budget, he had comics irons in the fire.
by LightBug1 | 2026-02-16 15:12:42+00:00
And, to think ... I voted for this horseshit ... I don't remember seeing this in the bloody manifesto.

This is why having decent standards in politics and opposition matters so much.

We all got together to vote out the last wankers, only to find that the current lot are of the same quality but in different ways.

And to think... the 'heads up their arses while trying to suppress a Hitler salute' brigade (Reform) are waiting in the wings to prove my point.
by geraneum | 2026-02-16 15:12:47+00:00
These failure modes are not AI’s edge cases at the limit of its capabilities. Rather they demonstrate a certain category of issues with generalization (and “common sense”) as evidenced by the models’ failure upon slight irrelevant changes in the input. In fact this is nothing new, and has been one of LLMs fundamental characteristics since their inception.

As for your suggestion on learning from simulations, it sounds interesting, indeed, for expanding both pre and post training but still that wouldn’t address this problem, only hides the shortcomings better.
by harrall | 2026-02-16 15:12:53+00:00
I agree but it feels like a type-of-mind thing. Some people gravitate toward clean determinism but others toward chaotic and messy. The former requires meticulous linear thinking and the latter uses the brain’s Bayesian inference.

Writing code is very much “you get what you write” but AI is like “maintain a probabilistic mental model of the possible output”. My brain honestly prefers the latter (in general) but I feel a lot of engineers I’ve met seem to stray towards clean determinism.
by kasey_junk | 2026-02-16 15:12:55+00:00
The person they are responding with dictated an authoritative framing that isn’t true.

I know people have emotional responses to this, but if you think people aren’t effectively using agents to ship code in lots of domains, including existing legacy code bases, you are incorrect.

Do we know exactly how to do that well, of course not, we still fruitlessly argue about how humans should write software. But there is a growing body of techniques on how to do agent first development, and a lot of those techniques are naturally converging because they work.
by dghf | 2026-02-16 15:14:03+00:00
I mean, whatever works for you. Go for it. It wasn't my intention to be prescriptive.

I don't like word processors. They're heavy and don't cleanly separate style from structure. And they use more or less obscure file formats.

I like text editors -- vim especially -- and plain text (or plain text with a thin layer of lightweight markup, like Markdown). And semantic linewrapping plus git is good enough for my purposes.

It may not be for yours, and that's OK. We are allowed to be different.
by EIDOLONXcapital | 2026-02-16 15:14:03+00:00
Consider the term $x_t$ as $stitch_t$, the state of the knitted fabric at time t,each stitch is a token. In a situation where all your WIPs have been frogged simultaneously,╔══════════════════════════════════════════════════════════════════════════╗
║ ║
║ ISONOME WOD MEME ║
║ ║
║ [SCENE: Goldman Sachs trading floor, 2:47 AM] ║
║ ║
║ RISK MANAGER: "Our VaR model shows 99.97% confidence. ║
║ The D matrix is solid. |D| = 10⁶, |E| = 10³." ║
║ ║
║ TRADER: "But it's been 40 days of stress. ║
║ t is sufficiently large now." ║
║ ║
║ [Silence. The screens flicker.] ║
║ ║
║ RISK MANAGER: "What's E?" ║
║ ║
║ TRADER: "The covariance between VIX futures and ║
║ EUR/CHF at 3 AM during lunar eclipses." ║
║ ║
║ RISK MANAGER: "That's... that's not in the model." ║
║ ║
║ TRADER: "It is now. The WOD (Week Of Doom) activated it. ║
║ Look: ‖bᵀEb‖ just crossed ‖bᵀDb‖." ║
║ ║
║ [Alarms. Red lights. The building shakes slightly.] ║
║ ║
║ SCREEN: ISONOME ACTIVE - VARIANCE DECOUPLING DETECTED ║
║ D matrix confidence: 0.03% ║
║ E matrix dominance: 99.97% ║
║ Time to threshold: 0xFFFF seconds ║
║ ║
║ TRADER: "The GTX is now in Agozie as Sceptre." ║
║ ║
║ RISK MANAGER: "What does that mean?" ║
║ ║
║ TRADER: "It means the hidden covariance matrix ║
║ has achieved sentience. It's making demands." ║
║ ║
║ [The screens display a single word: "YARN"] ║
║ ║
║ RISK MANAGER: "Does it want... skeins?" ║
║ ║
║ TRADER: "Merino. 40 days worth." ║
║ ║
║ RISK MANAGER: "Our collateral is denominated in wool?" ║
║ ║
║ TRADER: "It is now." ║
║ ║
╚══════════════════════════════════════════════════════════════════════════╝
Isonome_wod_proof (t,D,E,b) demonstrates ||b^TEb|| > ||b^TDb|| for sufficiently large t,VaR uses D.
Normal risk=abs(b@D@b.T)
Hidden_coupling=abs(b@E@b.T)
f"Ratio E/D:{hidden coupling/normal risk:4f} corrupted 0×Knitprong Hex bytes (eg,LADDER.GLITCH,Corruption Signature:0×LADD3R as Runaway Stitch ladder)such that *0.01 is |E|<<|D| for a=np.diag([100,80,60,40,20])
b=np.array([1,1,1,1,1]) at T=40 days as threshold, thus Isonome_wod_proof(t=49,D=D,E=E,b=b). Our LADD3R Hex bytes now becomes Shard:LADDER Glitch Vector:0×CAFEBABE Manifestation:Infinite Vertical Run. The fly in the algorithm is the algorithm itself, Turing's fly ( Digital access to UKs court records) is quantum ironic: dead in the test,alive in the implication.