AI nudges a math breakthrough & Statecharts tame complex software behavior - Hacker News (Apr 26, 2026)

A surprising AI-assisted moment in pure math: Liam Price, a 23-year-old amateur, reported a solution to a long-standing Erdős conjecture after prompting GPT-5.4 Pro and then posting the result to the Erdős Problems site. The conjecture is about “primitive sets” of integers—collections where no number divides another—and how a classic scoring function, the Erdős sum, behaves as the numbers get huge. What’s grabbing mathematicians isn’t that an AI typed up a proof; it’s that the model appears to have made an unconventional connection, pulling in a known formula from a neighboring area that researchers simply hadn’t tried in this context. Experts, including Terence Tao, describe the raw AI output as messy and not publication-ready, but with human reconstruction the core insight looks sound and has been streamlined. Why it matters: it’s a real example of AI acting like a cross-domain suggestion engine—useful for novel direction-finding—while human experts still do the heavy lifting on verification and clear exposition.

Staying with the human side of expertise, one essay made a sharp comparison between defense manufacturing and software engineering. The author points to cases like the struggle to restart Stinger missile production—where retirees, obsolete parts, and lost shop-floor knowledge turned “just spend money” into “wait years.” They also cite other examples where optimized peacetime supply chains couldn’t surge when the world changed. The warning for software is pointed: if companies lean hard on AI to generate code while also cutting junior hiring, they may be thinning the pipeline that produces future senior engineers. The claim isn’t that AI is useless—it’s that organizations can accidentally trade away tacit skills like debugging judgment, systems thinking, and technical leadership, because those are built through years of real incidents and mentorship. The takeaway: resilience is the theme. If the industry optimizes only for short-term throughput, it risks a future where key knowledge quietly disappears until there’s a crisis and nobody left who knows how to “make it work.”

On the topic of building reliable systems, Statecharts.dev published an accessible explainer arguing that statecharts are essentially “finite state machines, but grown up” for real software. The article frames statecharts as a visual formalism introduced by David Harel in 1987 to address the classic pain of big state machines: state explosion, where behavior becomes an unmanageable web of cases. The practical pitch is team-oriented—clearer behavior modeling, better separation between behavior and components, more straightforward testing, and a cleaner way to represent exceptional paths without turning the whole design into spaghetti. It also doesn’t ignore the downsides: there’s a learning curve, it’s a mindset shift, and for small systems it can feel like extra overhead. The interesting connective tissue is SCXML, a W3C standard that aims to pin down semantics so tools and libraries can handle edge cases consistently. And the article nods to “executable statecharts,” where the same definition drives runtime behavior and generates diagrams—reducing translation mistakes, while raising familiar concerns about tooling maturity and type-safety. Why it matters: if your product’s logic is getting harder to reason about, this is one of the few modeling approaches that tries to make complexity visible and testable rather than hidden in conditional code.

Now for something more visual—almost sci-fi, but very practical. PlayCanvas shared a walkthrough that turns a photorealistic Gaussian Splat scan into a playable browser FPS scene. Splats look great, but they’re typically just renderable geometry without solid surfaces for gameplay. The demo stitches together an end-to-end pipeline that makes the scan act like a real level: it streams progressively so devices don’t stall, generates collision so physics and shooting behave correctly, and adds navigation data so NPCs can move through the space. One clever bit is handling lighting: splats often have baked appearance that doesn’t naturally light regular game assets, so the demo approximates local brightness to keep characters and weapons visually consistent with the scanned environment. The big deal here is feasibility—this is a credible “scan-to-playable” workflow using open tooling and a public project others can fork. If this approach keeps improving, it lowers the barrier to building believable game spaces, simulations, or training environments directly from the real world.

A smaller story, but one that hits a nerve for platform trust: a Hacker News thread reports the Headspace app repeatedly reappearing on some iPhones after users delete it—even with automatic downloads disabled. Several commenters describe seeing the icon return daily, sometimes greyed out as if it’s pending download, often after iOS updates. The discussion leans toward this being an Apple-side regression—something in restore behavior, offloading logic, App Store server decisions, or device sync—rather than anything Headspace would intentionally attempt, since that would be incredibly conspicuous and risky. Why it matters: deleting an app is a basic user expectation. If the system can override that without a clear audit trail, it raises questions about control, privacy, and accountability. The recurring request from users is simple: better diagnostics and clearer logs that explain what triggered an install and why.

If you’ve ever lost an afternoon to cables and ports, you’ll appreciate this one. Fabien Sanglard published a USB cheat sheet after chasing a bug that turned out to be USB terminology confusion. Rather than drowning you in spec history, the page tries to map marketing names to what you can expect in real-world performance, and it highlights the gap between advertised signaling rates and actual throughput. It also clarifies why two cables that both look “USB-C” can behave completely differently, depending on what’s actually wired and supported. Why it matters: USB is a reliability trap—especially in labs, dev kits, and hardware-adjacent software work. A simple, trustworthy reference can prevent misdiagnosis, bad purchasing decisions, and those maddening “it works on my machine” hardware inconsistencies.

In security and privacy news, Werner Koch announced GnuPG 2.5.19. The release is a mix of fixes and small features across core components, plus ongoing work in the 2.5 line that’s especially focused on better support for 64-bit Windows and modern cryptography directions, including post-quantum algorithms. The headline for many users is lifecycle: GnuPG 2.4 is expected to hit end-of-life in about two months, and the maintainer is urging people to move to 2.5.19 while keeping compatibility with older setups. Why it matters: crypto tools tend to live at the bottom of dependency stacks, and upgrades get postponed until something breaks. An explicit EOL clock is a good reason to plan migrations before they become emergency work.

Finally, a classic topic done exceptionally well: Bartosz Ciechanowski published a deep-but-readable explanation of IEEE 754 floating-point. The framing is simple: floats are base-2 scientific notation with strict limits on precision and exponent range, and those constraints create the “surprises” developers trip over—like why common decimals can’t be represented exactly, why rounding errors accumulate, and why some ranges of numbers have big gaps between representable values. The article also covers the special values—zeros, infinities, NaNs, and subnormals—and ties it back to practical debugging, including how the way we print numbers can hide what’s truly stored. Why it matters: floating-point misunderstandings show up as flaky tests, finance bugs, graphics artifacts, and incorrect comparisons. Better mental models here pay dividends across almost every domain of software.