MurphyA/hacker-news huggingface dataset:
by grumpyprole | 2026-02-22 08:30:16+00:00
> The big thing is that if you have a bare string, you don't know "where it's been". It doesn't carry with it information whether it's already been validated.

> For full-on parse-don't-validate, you essentially need a dependent type system

This is really misleading. You are missing abstract types in your arguments. If the only way to construct the newtype is a via a parser (smart construction) because the type constructor is not exported, then the newtype does carry the information that the string has been validated.
by illiac786 | 2026-02-22 08:30:17+00:00
Thank you for this. The poor always vote against themselves I have the impression. Far right plan to hand over the country to megacorps et remove all social nets in Germany. Guess who votes for them more than other social categories? The one that would be most impacted by this. It’s insane.

At the same time, it’s a testament to the weakness of other parties that they can’t even articulate that sufficiently well.
by chickensong | 2026-02-22 08:31:23+00:00
I agree with most of this, though I'm not sure it's radically different. I think most people who've been using CC in earnest for a while probably have a similar workflow? Prior to Claude 4 it was pretty much mandatory to define requirements and track implementation manually to manage context. It's still good, but since 4.5 release, it feels less important. CC basically works like this by default now, so unless you value the spec docs (still a good reference for Claude, but need to be maintained), you don't have to think too hard about it anymore.

The important thing is to have a conversation with Claude during the planning phase and don't just say "add this feature" and take what you get. Have a back and forth, ask questions about common patterns, best practices, performance implications, security requirements, project alignment, etc. This is a learning opportunity for you and Claude. When you think you're done, request a final review to analyze for gaps or areas of improvement. Claude will always find something, but starts to get into the weeds after a couple passes.

If you're greenfield and you have preferences about structure and style, you need to be explicit about that. Once the scaffolding is there, modern Claude will typically follow whatever examples it finds in the existing code base.

I'm not sure I agree with the "implement it all without stopping" approach and let auto-compact do its thing. I still see Claude get lazy when nearing compaction, though has gotten drastically better over the last year. Even so, I still think it's better to work in a tight loop on each stage of the implementation and preemptively compacting or restarting for the highest quality.

Not sure that the language is that important anymore either. Claude will explore existing codebase on its own at unknown resolution, but if you say "read the file" it works pretty well these days.

My suggestions to enhance this workflow:

- If you use a numbered phase/stage/task approach with checkboxes, it makes it easy to stop/resume as-needed, and discuss particular sections. Each phase should be working/testable software.

- Define a clear numbered list workflow in CLAUDE.md that loops on each task (run checks, fix issues, provide summary, etc).

- Use hooks to ensure the loop is followed.

- Update spec docs at the end of the cycle if you're keeping them. It's not uncommon for there to be some divergence during implementation and testing.
by spiffe | 2026-02-22 08:31:58+00:00
Thanks, but I'm likely going to tune out.

None of the 3 points address the fundamental issue. IMO, it appears you are trying to reinvent a tiny part of OAuth2 w/ DCR, but without any of the security or trust underpinnings. I'd encourage you to consider simply using OAuth2 w/ DCR for your agent app instead.
by jmholla | 2026-02-22 08:33:36+00:00
I doubt it. This bill has extremely deep problems.

The constrain of a "real-time application programming interface" has no legislative priors and little concrete technical merit. This requirement on its face requires that all operating systems provide some level of guaranteed response time, as a real-time OS would. But what that guarantee is, is unspecified. Not to mentions the reasonably consistent part.

But, such a file may not necessarily exist. And given that the onus is from operating systems and not those running the operating system. The existence of a file (or lack there of), is not a sufficient guarantee.

Further, this provides only one bucket the law requires. The file(s) in question MUST be more nuanced with the law as it is written.

The real fuckery of this bill: it pretends to be privacy preserving and to protect minors, but the only people whose personal birth date information can be leaked by its implementaiton are minors.
by ffsm8 | 2026-02-22 08:35:13+00:00
"radically different" and yet exactly the same as almost every other guide on these CLI tools before plan mode was introduced. Checks out

You could mostly recreate this article with an LLM trained on the web as of September 2025 with a simple prompt like "write an insightful article about how to develop with Claude code"

Down to the task list, which itself has generally been superseded by beads
by koevet | 2026-02-22 08:35:53+00:00
Has anyone found a efficient way to avoid repeating the initial codebase assessment when working with large projects?

There are several projects on GitHub that attempt to tackle context and memory limitations, but I haven’t found one that consistently works well in practice.

My current workaround is to maintain a set of Markdown files, each covering a specific subsystem or area of the application. Depending on the task, I provide only the relevant documents to Claude Code to limit the context scope. It works reasonably well, but it still feels like a manual and fragile solution.
I’m interested in more robust strategies for persistent project context or structured codebase understanding.
by jclulow | 2026-02-22 08:36:47+00:00
This is not an accurate assessment in the StarCraft II case. It was released in 2010, and LAN play was definitely still popular. I remember because I was part of a University club/society that was running ~200 person ~3 day LAN parties at the time, and I recall the intense loathing we had for how incredibly difficult Blizzard had decided to make it to actually play the game you had paid for, on your own network.

If anything, LAN play became less popular because it was intentionally hampered by Blizzard and other companies.
by homeboxer26 | 2026-02-22 08:37:19+00:00
Incidentally, I built something for exactly this use case and just posted it as a Show HN: a mini PC that ships pre-loaded with OpenClaw (an open-source claw runtime) and runs at 15W for always-on deployment. The idea is to remove the friction of "set up a VM, install the framework, keep it running" for people who just want a persistent claw at home.

https://news.ycombinator.com/item?id=47109365

Happy to discuss the hardware tradeoffs if anyone's gone down this path.
by oblio | 2026-02-22 08:39:20+00:00
The studies I can't point you to, but there were lots of blogs by the lead Office UX person at the time, Jensen Harris.

https://learn.microsoft.com/en-us/archive/blogs/jensenh/

Unfortunately those blog entries have been destroyed because the images are no longer there.

I read all of them, they were at least 6-7 and quite detailed and I remember thinking that the thought process behind the ribbon was very solid.

https://learn.microsoft.com/en-us/archive/blogs/jensenh/the-...

https://learn.microsoft.com/en-us/archive/blogs/jensenh/ye-o...

etc - you can find all of them there plus many other related blog entries.
by efskap | 2026-02-22 08:39:32+00:00
Reminds me of a 2011 reddit post (obviously in the format of a rage comic) that led to the formation of r/playdate, although that shifted to just looking for people to play games with over the years.

https://www.reddit.com/r/gaming/comments/j8hpz/idea_for_subr...

I love seeing the original concept brought back with a cool UI.
by az09mugen | 2026-02-22 08:39:58+00:00
Same here, partial code from stackcodegen.ml in the said archive :

open Op;;
open Var;;
open Ctx;;
open Ltal;;
open Util;;

let debug msg = ();;

let rs = mkvar "rs";;
let ra = mkvar "ra";;
let rf = mkvar "rf";;
let rt = mkvar "rt";;
let rr = mkvar "rr";;
let ru = mkvar "ru";;

let retty stackty aty = (Code(Ctx.from_list[(rs,stackty);
(ra,aty);
(rt,toptp);
(rf,listtp);
(rr,toptp)]))

let rec tt tctx ctx tp =
match tp with
Il.TVar a -> if bound tctx a then TVar a else lookup ctx a
| Il.Int -> DTp Word
| Il.Top -> DTp Top (* for now )
| Il.Tensor(t1,t2) -> Ref(Tcltal.mkpair (tt tctx ctx t1, tt tctx ctx t2))
| Il.Exists (alpha, tp) ->
let beta = rename alpha in
Exists (beta, W, tt tctx (extend ctx alpha (TVar beta)) tp)
| Il.List t ->
let tv = mkvar "list" in
Mu(tv,NRef(Tcltal.mkpair(tt tctx ctx t, TVar tv)))
| _ -> DTp(arrowtt tctx ctx tp)

and arrowtt tctx ctx t =
match t with
Il.Forall(alpha,t) ->
let beta = Var.rename alpha in
Forall(beta, W, arrowtt tctx (extend ctx alpha (TVar beta)) t)
| Il.Arrow(t1,t2) ->
let t1' = tt tctx ctx t1 in
let t2' = tt tctx ctx t2 in
let stk = mkvar "s" in
Forall (stk,M,
Code(Ctx.from_list[(rs,Stack(Tensor(t1',MTVar stk)));
(ra,toptp);
(rt,toptp);
(rf,listtp);
(rr,DTp(retty (Stack(MTVar stk)) t2'))]))

| _ -> tcfail "expected a function type in forall"

let typetrans tctx tp = tt tctx Ctx.emp tp
let arrowtypetrans tctx t1 t2 = arrowtt tctx Ctx.emp (Il.Arrow (t1,t2))

( Need to specify the type ty of "the rest of the stack", in most cases
alpha )

type code_env = {cctx : cctx;
cs : code_section;
fctx : Il.ctx;
lctx : var Ctx.ctx;
fp : int}

let get_fctx cenv = cenv.fctx
let get_lctx cenv = cenv.lctx

type block_env = {cenv : code_env;
ilist : instruction list;
lab : clab;
tctx : Ltal.tctx;
rctx : Ltal.rctx}

let get_from_cenv f benv = f benv.cenv

exception CodeFail of string code_env
exception BlockFail of string * block_env

(*
val begin_fn : code_env -> clab -> register_file -> block_env
val end_fn : block_env -> code_env
val emit_label : fn_env -> clab -> dtp -> block_env
val emit : block_env -> instruction -> block_env -> block_env
val emit_end : end_instruction -> block_env -> fn_env
val drop : reg -> block_env -> block_env
val free : reg -> block_env -> block_env
val push : reg -> reg -> block_env -> block_env
val pop : reg -> reg -> block_env -> block_env
val malloc : reg -> block_env -> block_env
)

let do_print y x = (debug y; x)

let (>>) f g x = g(f(x))
let (>>=) f h x = let y = f x in h y x

let rec mkltp tctx rctx =
Ctx.fold (fun t sk dtp ->
let k = match sk with _,W -> W | _,M -> M in
Forall(t,k,dtp))
tctx (Code (rctx))

let current_ltp benv =
debug ("Generalizing "^(Ctx.pp_ctx (fun _ -> "") benv.tctx)^"\n");
( rt is caller-save *)
let rctx = update benv.rctx rt toptp in
(mkltp benv.tctx rctx)
by andersmurphy | 2026-02-22 08:40:36+00:00
I mean once campfire is full featured free and easy to self host. Completely open source slack replacement.

I imagine it's also infinitely better than anything an in house team could vibe code.

You don't need AI for a cheap slack alternative.

That's why I don't buy any of this.

Companies are not bothering with the free/open alternatives.

Unless the real power of LLMs is making it easy for greg in HR to self host these existing alternatives. But, that a trillion dollar market does not make.
by walletdrainer | 2026-02-22 08:40:58+00:00
Every single person who has bought the phishing kit claims the seller is a scammer. Krebs’s article is based entirely on the sellers description of the (imaginary) product, rather than actual observation of the phishing kit in the wild.

See the exploit.in thread for example https://temp.sh/XOWUP/STARKILLER_V6.0.1___ULTIMATE_WEAPON__B...

Krebs has access to these forums, he could’ve checked this story out in less than 3 minutes but did not.

Even if Krebs wasn’t a subject matter expert, it’s still inexcusable that he didn’t do the most basic work here. You don’t need to frequent underground runet forums to know that a journalist should be able to verify the stories he puts out.

I think it’s also particularly telling that he didn’t bother to source reasonable quality screenshots for the story, which he would have been able to do had he ever witnessed this phishing kit working.
Show HN: Fishline – A lightweight pipeline queue for Go
by hyvr_official | 2026-02-22 08:42:32+00:00
I built Fishline, a lightweight self-hosted webhook receiver for GitHub and GitLab that lets you execute server-side commands based on webhook events.
Instead of setting up complex CI/CD pipelines, Fishline simply listens for webhook requests and runs predefined commands per project and branch things like git pull, restarting Docker containers, or triggering deployments.
You just configure projects and commands in a simple config.json, point your GitHub/GitLab webhook to your server, and deployments happen automatically.
Built in Go, runs as a single binary (or Docker), and designed to be minimal, fast, and easy to self-host.
by walletdrainer | 2026-02-22 08:43:08+00:00
https://temp.sh/XOWUP/STARKILLER_V6.0.1___ULTIMATE_WEAPON__B...

These forums are mostly private, but Krebs certainly has access to them. There can really be no excuse for how he handled this.

There are multiple posts by people in different places claiming to have bought this phishing kit, and then being delivered totally non-functional vibecoded garbage. The vibecoded garbage is not the advertised product though, as the author never managed to get the AI to finish his project.
by hashmap | 2026-02-22 08:44:35+00:00
i literally suggested this metaphor earlier yesterday to someone trying to get agents to do stuff they wanted, that they had to set up their guardrails in a way that you can let the agents do what they're good at, and you'll get better results because you're not sitting there looking at them.

i think probably once you start seeing that the behavior falls right out of the geometry, you just start looking at stuff like that. still funny though.
by menaerus | 2026-02-22 08:45:15+00:00
Not sure what you're on but I think what you said is incorrect. You can use hi-density HBM-enabled FPGA with (LP)DDR5 with sufficient number of logic elements to implement the inference. Reason why we don't see it in action is most likely in the fact that such FPGAs are insanely expensive and not so available off-the-shelf as the GPUs are.
by Razengan | 2026-02-22 08:45:21+00:00
Games like StarCraft, CounterStrike, Warcraft 3/DotA etc were and still are popular in "cybercafes" etc.

Hell that LAN environment WAS the reason StarCraft got so hugely popular in the first place, before Blizzard got jealous and wanted to have their fingers in everything.

Now, when the servers inevitably get graveyarded permanently some day, how is anybody gonna play SC2 or any of the always-online games?

> it's just that you don't want to develop, support and test features

Just let one player's machine host some of the same server code they use for their internet services?

> multiplayer via LAN is such a marginal feature nowadays

WHY?? Literally everybody has phones now, but how many local multiplayer games are there? Imagine if you could just bop your phone to your friends' and immediately start playing something together. The technology and social saturation has never been more favorable than now, but as always it's corporate greed/spying which is the biggest antifun cancer everywhere.
by ludicrousdispla | 2026-02-22 08:47:38+00:00
Nice paper, the last two figures remind me of Hierarchical Edge Bundles (2006) and the Sunflower Visual Metaphor (1999) which have similar goals.

https://aviz.fr/wiki/uploads/Teaching2014/bundles_infovis.pd...

https://ics.uci.edu/~kobsa/courses/ICS280/notes/papers/Rose-...
by astrobe_ | 2026-02-22 08:48:02+00:00
In communication protocols, you typically send a symbol which tells the receiver the meaning and the syntax of the message, and then the data attached to the message.
In technical terms, messages belong to different application protocol data units ("APDU"). The receiver typically uses the APDU symbol (which can be just e.g. a byte) to dispatch the message internally to the right processing routine.

Message passing in OOP is the same thing, and it's ultimately about late binding. Late binding has, indeed, as much presence as dynamic typing in Forth, contrary to other scripting languages like Lisp or Lua where they are cornerstones, so to speak. Forth is firmly in the early binding camp, to the point that it does even know forward declarations [1]. Forth programmers won't do anything unnecessary, and so they expect their system won't do anything they don't need.

[1] Many scripting languages realized that skipping declarations to be "user-friendly" was a big design mistake and eventually implemented some sort of "strict" mode that became the de facto default. So they have two language features that cancel each other...
by no-name-here | 2026-02-22 08:48:09+00:00
I would have expected the non-solved-cases to be the relatively unique ones, but considering the plethora of both A) non-Electron desktop apps, and B) coding agents (Copilot/Windsurf/Cursor/Codex/OpenCode/Qwen/Amazon Kiro/Devin/JetBrains AI/Gemini CLI/Gemini Code Assist/Antigravity/Warp/Kilocode/Cline/RooCode/Atlassian Rovo/Claude Code/etc), it seems like neither of the building blocks is very rare - perhaps Claude is just incapable of putting it together?
by aidenkt | 2026-02-22 08:48:27+00:00
I really like your UI (cool typeface especially), my biggest problem so far just poking around is how I don't exactly see how this differs from say Twitter/X or Bluesky outside of being marketed as Developer focused. I think implementing more features that are specific to developers, such as integrating with Git repos, would be a great step toward making your platform more unique. For 15, this is very impressive.
by hathawsh | 2026-02-22 08:49:01+00:00
That sounds like the recommended approach. However, there's one more thing I often do: whenever Claude and I complete a task that didn't go well at first, I ask Claude what it learned, and then I tell it to write down what it learned for the future. It's hard to believe how much better Claude has become since I started doing that. I ask it to write dozens of unit tests and it just does. Nearly perfectly. It's insane.
by geoelectric | 2026-02-22 08:50:22+00:00
I think that's a pretty bold claim, that it'd be different every time. I'd think the output would converge on a small set of functionally equivalent designs, given sufficiently rigorous requirements.

And even a human engineer might not solve a problem the same way twice in a row, based on changes in recent inspirations or tech obsessions. What's the difference, as long as it passes review and does the job?
by mmarq | 2026-02-22 08:50:26+00:00
The problem with this is that private health insurance is very cheap because there is an NHS that takes care of emergencies and does more than 50% of the rest. So your taxes keep your health insurance premia low.

Otherwise a comprehensive health insurance wouldn’t cost 200£ a month per person (I just requested a quote from AXA, as a 45 year old with no health problems, adding all packages, unlimited specialist visits and no excess)
by dugidugout | 2026-02-22 08:51:46+00:00
I mean the barriers you are describing are at the same time why I and others enjoy playing fighting games.

Further, I dont know when you've tried picking one up last, but any title in the last few years has plenty of concern for "accessibility" especially regarding inputs.

Most competitive spaces can be described as "some gated community to me that’s closed for anyone not willing to pour in the hours to learn".
by charkubi | 2026-02-22 08:52:29+00:00
Planning is important because you get the LLM to explain the problem and solution in its language and structure, not yours.

This shortcuts a range of problem cases where the LLM fights between the users strict and potentially conflicting requirements, and its own learning.

In the early days we used to get LLM to write the prompts for us to get round this problem, now we have planning built in.
by ookblah | 2026-02-22 08:52:44+00:00
a lot of low level ops stuff is going to be eaten up imo. half the bullshit you have to deal with is integrating data across every platform you are using or other supposed products to help you integrate the integrators lol. i guess if you're a huge company with 1000s of people this is an inherent problem anyway, one you can spend millions of dollars on.

it's not just "replace snowflake", there are a lot of times i wish i could build a very focused thing to accelerate some of our internal workflows and the nocode solutions either were too simplistic that you ended up spending just as much time trying to wrangle some generic solution to your own use case. OR it was not worth throwing significant engineering resources behind internal ops stuff. now that barrier is dropping fast and it's feasible for us.

whoever can create the framework/tooling for people build their own systems will win this, but i don't think it's something that can be "productized" like a saas.
by armchairhacker | 2026-02-22 08:52:53+00:00
How do you ensure the hash isn’t tampered? Usually if you’re saving the hash, you can save the whole archived page. Otherwise, you could hash the archived page itself.

The only way I know to ensure an archive isn’t tampered is to re-archive it. If you sent a site to archive.today, archive.org, megalodon.jp, and ghostarchive.org, it’s unlikely that all will be tampered in the same way.
by KronisLV | 2026-02-22 08:53:32+00:00
> Honestly does show how the industry has failed to bring simple things like localized cron and scheduling to personal compute too.

I looked at task scheduling on Windows and while the UI was usable, I cannot imagine any regular person using that. Just doing crontab -e feels way simpler and has less friction, BUT it doesn't really help you much with task statuses and re-running them and reporting/alerting/notifications (past MTA) and all the stuff, past "Oh hey, every day at 04:00, run this shell script."

I wonder why people haven't gotten the green light from their bosses or investments to improve OS functionality and write tools that improve general usability and just slap some basic AI on top of that for the checkmark: "Hey boss, I spent the last month and wrote a task scheduling and management GUI for Windows that's really approachable, we can totally also use this for the current AI/Copilot/claw trend wink wink."