Hacker News is obsessed with durable Postgres workflows and a game about clicking yes

Hacker News spent the last week of May 2026 arguing about two things: whether you really need a workflow engine, and whether you really read what your AI agent is about to run. Both debates topped the front page between May 24 and May 28.

These six aren’t ranked by points. They’re ranked by how much they’ll change a normal developer’s week. A couple are tools you’d install today. One is a release you’ll upgrade into. And one is a genuine mystery nobody has solved yet.

The list

The durable-Postgres post pulled 308 points, the highest of the bunch, with the LLM-smells catalog (287) and the permission-fatigue game (303) close behind. That three of the top items circle AI tooling tells you where developer attention sits right now: not on whether to use these tools, but on how to keep them from quietly making things worse. Here’s the full set, newest debates first.

Durable workflows on just Postgres

The post that won the week was DBOS’s argument that you can get durable execution without Temporal, without a separate orchestrator, without a queue. Just a Postgres table holding each step’s checkpoint. Crash mid-workflow, restart, and the program resumes from the last completed step. It pulled 308 points and 132 comments.

The pitch lands because most teams already run Postgres. Adding a “workflow engine” means a second system to deploy, monitor, and reason about. Keeping state in the database you already trust is a real simplification, and the author claims tens of thousands of workflows per second once you stop fighting lock contention.

But the top comment is the one to read first. It points out that “just a database” stays clean only until you need retries, backoff, timeouts, cancellation, and versioning. At that point you’ve rebuilt a workflow engine inside your schema. Another commenter flags the operational tax of the SKIP LOCKED pattern: at scale, vacuum can’t keep up with dead tuples and the planner gets weird. Worth a pilot. Not a default.

A field guide to LLM code smells

Shiv’s “Various LLM Smells” hit 287 points and 220 comments by naming the tells that AI-assisted work leaves behind. It’s the kind of post that makes you wince at your own recent diffs.

The catalog is concrete. There’s the excessive punchline, sentences over-engineered for a quip (“Symmetry becomes a trap”). There’s the staccato fragment run, short sentences stacked for fake impact. There’s the “X is the Y of Z” construction, a metaphor template models reach for constantly. And there’s the visual version: AI-built sites that all ship the same JetBrains Mono font, the same card layout, the same blinking-dot status badge.

Why it resonated: these patterns now show up in real pull requests, not just blog spam. The caveat the comments raised is fair, though. Some of these “smells” are just good writing or common UI choices, so treat the list as a prompt for a closer look, not as a detector you can run blind.

Continue? Y/N, the permission-fatigue game

Continue? Y/N is a 60-second browser game where you play the human approving an AI agent’s commands, and the whole point is that you’ll start rubber-stamping. It pulled 303 points as a Show HN. Play it once and you get the joke immediately.

The design rests on a real number. Anthropic telemetry cited around the launch suggests users approve roughly 93% of permission prompts, and attention drops with every approval. You okay a file write, a shell command, another file write, and twenty prompts in it’s muscle memory. The game splices one genuinely dangerous command into the stream and watches you wave it through.

It pairs well with the broader worry that approve-everything UX defeats the purpose of a permission gate at all. The catch is that it’s a toy, not a tool: it diagnoses the problem sharply but doesn’t fix your actual agent setup. If it stings, that’s the feature.

Rust 1.96 lands two things people asked for

Rust 1.96.0 shipped on May 28 with a change that touches everyday code: copyable range types. For years Range implemented Iterator directly, so it couldn’t be Copy, which meant storing a slice accessor was annoying. The new range types implement IntoIterator instead, so they’re Copy and stop fighting the borrow checker.

The release also adds assert_matches! and debug_assert_matches! that print the Debug value on failure instead of a bare panic, which saves real debugging time. WebAssembly builds got stricter too: the linker now rejects undefined symbols rather than quietly turning them into env imports.

Two security fixes ship for users of third-party crate registries (CVE-2026-5223 and CVE-2026-5222); crates.io users aren’t affected. If you write Rust, this is a plain upgrade. We’ve covered the language’s tooling momentum before in our look at Zed’s 1.0 launch.

The Hy3 mystery and a tidy JVM Wasm runtime

Two smaller items round out the week, and the first is a genuine puzzle. Max Woolf’s writeup digs into Hy3, a model that quietly topped OpenRouter’s usage rankings by more than 50% over Claude on token volume, despite nobody having heard of it. It turns out to be a Tencent mixture-of-experts model priced around $0.034 per million input tokens, with no usage data before May 8 and steady organic growth since. Cheap and agentic-tuned beats famous, apparently. That’s a signal worth tracking if you route traffic by price, a theme we touched on in our piece on Claude Code’s doubled rate limits.

The other is Endive, a pure-JVM WebAssembly runtime now under the Bytecode Alliance, forked from Dylibso’s Chicory and sitting at 102 stars. It runs Wasm anywhere the JVM runs, no JNI and no native libraries, so you ship one JAR everywhere. You add a Maven dependency and pick interpreter, runtime compiler, or build-time compiler. Niche today, but it’s the cleanest answer yet for Java shops that want sandboxed plugins without native baggage.

Our pick

Durable workflows on Postgres is the one to watch, but not for the reason it trended. The interesting part isn’t “Postgres can do this.” It’s the top comment’s framing: the choice isn’t database versus orchestrator, it’s which complexity you want to own. If your workflows are mostly happy-path with light retries, owning a Postgres table beats running Temporal. The moment you need versioning, cancellation, plus human-in-the-loop steps, you’re building an engine anyway, and a real one will have already solved the edge cases you haven’t hit yet.

So here’s the test before you adopt it. Sketch your nastiest workflow, the one with a payment, a refund, and a partial failure in the middle. If plain Postgres still looks clean for that case, the simple path is yours. If it doesn’t, you just found out for free.