This morning’s selection skews toward tools, infrastructure, and a surprising amount of argument about what counts as real understanding, whether that means interval arithmetic, Emacs trust boundaries, human evolution, or writing code without leaning too hard on AI. I’ve kept the focus on what each linked piece actually says, then on what the HN thread argued about around it.

Tech Tools & Projects

Show HN: I made a calculator that works over disjoint sets of intervals

Summary: Victor Poughon’s calculator works on unions of intervals rather than single numbers, which means expressions can legitimately produce multiple separated ranges instead of one coarse bounding box. The point is not just to make weird math prettier, but to preserve the inclusion guarantees that make interval arithmetic useful when floating-point imprecision creeps in. The demo shows why this matters with cases like inverse squaring, where the mathematically correct answer is naturally disjoint. It is a small tool, but it makes a specialized numerical idea immediately legible.

HN Discussion: Commenters quickly got into notation, especially how to show open versus closed bounds and what to do at infinity. Others connected the project to interval-based graphing and implicit-surface work, while the author stressed that the real pleasure of the tool is seeing interval union arithmetic behave correctly on expressions ordinary calculators flatten or misstate.

A simplified model of Fil-C

Summary: This post tries to make Fil-C understandable without making readers swallow the full production implementation. The simplified model rewrites C and C++ so every pointer carries an accompanying allocation record, then shows how assignments, function calls, returns, and standard-library calls are transformed to move that metadata around safely. The result is a memory-safety story for C-family code that is concrete enough to reason about, instead of hand-wavy. It is essentially a guided tour of how to retrofit safety checks into a language that never expected them.

HN Discussion: Supporters loved the premise because it offers a path other than “rewrite everything in Rust.” Skeptics replied that it still smells like a fat-pointer design, which brings the usual questions about ABI compatibility, overhead, and what happens at boundaries with code that does not share the same representation. A smaller but useful side thread pointed to Bazel tooling for trying Fil-C in hermetic builds.

Brunost: The Nynorsk Programming Language

Summary: John Mikael Lindbakk introduces Brunost as a deliberately Norwegian programming language, written around Nynorsk instead of English keywords. The accompanying article describes it as an interpreted functional language with loose types, implemented in Zig, and leans hard into the cultural joke that Nynorsk is primarily a written standard, making it perfect material for a syntax experiment. The charm is not that Brunost solves a programming problem nobody else could solve. It is that the language turns linguistic identity, standardization, and local in-jokes into language design choices.

HN Discussion: The lone substantive thread came from someone who took the premise seriously enough to nitpick it, pointing out keywords that felt more Bokmål than Nynorsk. That same comment proposed stricter grammatical agreement and more idiomatic vocabulary, which made the discussion more interesting than a generic “fun project” reaction. Even in a tiny thread, the project worked because it invited language-politics criticism instead of escaping it.

The Unix executable as a Smalltalk method (2025) [video]

Summary: Joel Jakubovic’s talk argues that the familiar analogy between Unix and Smalltalk does not go far enough. Rather than merely comparing files to objects, he proposes treating the Unix executable as the analogue of a Smalltalk method, which in turn suggests a filesystem-backed way of realizing a Smalltalk VM. The theory is elegant because it reframes Unix artifacts as part of a message-passing object world without sealing everything inside an image. The practical snag, as the talk admits, is the sheer overhead of Unix processes.

HN Discussion: The HN thread was mostly a prior-art exchange instead of a fight over the thesis itself. One comment linked an earlier submission of the paper, and another dug up an older patent plus NeWS-era work that tried to express object hierarchies and methods through the filesystem and shell. So the conversation read more like historical annotation than acceptance or rejection.

Introducing: ShaderPad

Summary: ShaderPad is Riley J. Shaw’s attempt to remove the repetitive scaffolding from putting shaders on personal websites. It is aimed at people who already sketch in places like ShaderToy or TouchDesigner but want to publish those pieces on their own sites without rebuilding resize logic, history buffers, save and share helpers, and input plumbing every time. The interesting detail is how opinionatedly practical it is: this is not a grand graphics framework, just a toolkit extracted from one person’s repeated artistic workflow. That narrowness is part of the appeal.

HN Discussion: Readers compared it with more declarative shader components such as shader-doodle and shaderview, basically asking whether the right abstraction is a tiny library or a custom HTML element. Others were charmed by the examples and the late-night internet prompt on the site itself. There was also a housekeeping thread where commenters fixed a broken examples link in the launch post.

Generating a color spectrum for an image

Summary: Amanda Hinton’s writeup is a design diary for Chromaculture’s Spectrimage analyzer, a tool meant to show the full color composition of a photograph rather than a handful of representative swatches. She begins with median cut quantization, realizes it is solving the wrong problem because it equalizes buckets for compression, then iterates toward a display that preserves both prevalence and hue ordering. The post is good because it shows several wrong-but-reasonable attempts before arriving at the final spectrum. You can see the visualization problem getting clearer as the implementation changes.

HN Discussion: Most of the discussion was about how to keep rare colors visible without turning the graphic into noise. People suggested log scaling, minimum heights, or using another visual channel to distinguish “barely present” from “not present.” Others simply said the later iterations captured an image’s feel much better than flat palette bars, and one practical question was whether the code had been published.

Detecting DOSBox from Within the Box

Summary: Datagirl asks a wonderfully narrow question: if you are running inside DOSBox, how do you tell, from inside the emulated machine, that you are not on real DOS? The post moves past the obvious BIOS-string hack and instead explores quirks exposed by built-in commands, implementation choices, and the fact that DOSBox is emulating an experience rather than recreating a literal historical stack. It reads like emulator forensics, equal parts curiosity and reverse-engineering. The fun comes from seeing where authenticity leaks.

HN Discussion: Commenters replied with their own detection tricks, including a tiny QBasic floating-point test that reveals differences between some DOSBox builds and real hardware behavior. Others started wondering how the same style of probing would work for Concurrent DOS or other DOS-like systems. A third thread appreciated that the post exploited DOSBox’s convenience features rather than just rummaging for an identifying string.

A Python Interpreter Written in Python

Summary: Allison Kaptur’s chapter on Byterun is a teaching project disguised as a runtime. Instead of attempting to rebuild all of Python, it focuses on the bytecode interpreter, which lets readers see the stack machine, frame handling, and execution model without disappearing into parser complexity. That keeps the project small enough to understand while still answering the natural question of how Python actually runs Python. The payoff is conceptual, not competitive: after reading it, CPython feels less magical.

HN Discussion: One line of argument distinguished a self-hosted compiler from an interpreter that still depends on an existing interpreter at runtime, and not everyone found the analogy convincing. Others said the bytecode-first approach is exactly why the project works as a teaching artifact, because it reaches the interesting internals without becoming a full language implementation. A few readers also corrected details in the article’s language-runtime comparisons, especially around Perl.

A better R programming experience thanks to Tree-sitter

Summary: rOpenSci’s post is really two things at once: a gentle explanation of parsing, and a concrete case for why an R grammar for Tree-sitter matters. The grammar unlocks better formatting, linting, code search, autocomplete, hover help, and editor support in tools including Air, Jarl, Positron, and GitHub search. What makes the article useful is that it does not treat grammar work as invisible plumbing. It shows how a better parse tree reaches all the way up into ordinary editing ergonomics.

HN Discussion: One commenter said the article immediately pushed them to build a static-analysis extension for targets pipelines in VS Code, which is exactly the kind of downstream tool the piece is trying to enable. Longtime R users also noted that RStudio has shipped some of these comforts for years, so the novelty depends on whether you live inside that ecosystem or outside it. The rest of the thread was basically appreciation for Tree-sitter as unglamorous but powerful infrastructure.

---

Security & Privacy

Towards trust in Emacs

Summary: Eshel Yaron’s post introduces trust-manager, an Emacs package meant to stop the editor from treating every file it sees as equally safe. The argument is that older Emacs versions made too many trust assumptions, especially around features like file-local behavior, and that the editor needs a clearer distinction between trusted and untrusted sources. Rather than a manifesto about perfect sandboxing, this is a practical attempt to put a real security boundary where there previously was mostly convention. It is a very Emacs solution to a very Emacs problem.

HN Discussion: The first pushback was ergonomic: people do not want innocent things like scratch to feel untrusted by default. Another thread argued that Emacs is overclassifying macro expansion and related forms as dangerous, which risks training users to grant blanket trust just to get work done. That broadened into a more general complaint that modern developer tools keep demanding sweeping permissions when users mostly want something closer to scoped capabilities.

”cat readme.txt” is not safe if you use iTerm2

Summary: Calif’s writeup takes a command everyone assumes is inert and shows how iTerm2’s feature set can make it dangerous. The issue lives in iTerm2’s SSH integration, which bootstraps a remote helper and then uses a richer protocol over the PTY; a malicious file can emit output that impersonates part of that protocol and trigger code execution. That is why the post lands so hard: the exploit path goes through terminal features users barely think about once they are enabled. It is not a shell bug, it is a trust bug in the surrounding tooling.

HN Discussion: The fiercest criticism was about disclosure timing, since the detailed writeup appeared before a stable release had shipped the fix. Commenters also placed the bug in a long family of output-driven terminal, pager, and editor vulnerabilities, which made the exploit feel alarming but not unprecedented. A useful corrective in the thread was that rewriting in Rust would not automatically solve this one, because the problem is a protocol and product-design mistake more than memory unsafety.

---

AI & Tech Policy

Spending 3 months coding by hand

Summary: Miguel Conner writes from a strange and timely position: someone who spent the last two years building AI agents, then deliberately stepped away for a three-month retreat to code mostly without them. The essay is not nostalgic cosplay. It is about protecting the mental model you build while writing code yourself, especially when agentic workflows tempt you to skip straight to output. Because the author has firsthand experience with LLM-based systems, the piece reads less like rejection and more like a deliberately imposed training constraint. He is trying to keep the underlying skill from atrophying while the tooling gets better.

HN Discussion: A lot of commenters agreed with the premise but drew the line in a different place, saying autocomplete remains useful while full agent delegation often severs understanding. Others brought in examples from teaching and low-level programming to argue that struggling through the thing yourself still has educational value. A smaller group described hybrid workflows where AI drafts, reviews, or catches edge cases, but the human still owns the architecture and the final understanding.

Are the costs of AI agents also rising exponentially? (2025)

Summary: Toby Ord’s argument is that people keep extrapolating the improving task horizon of AI agents without asking what it costs to achieve that frontier. His answer is uncomfortable: longer-task performance may be improving partly because models are bigger, invoked more aggressively, and much more expensive in the regimes where they look most capable. That does not mean the capability trend is fake. It means the economically relevant curve may look very different from the headline benchmark curve, especially when you pay for failed runs too.

HN Discussion: Readers immediately attacked the benchmark frame, saying frontier closed models are the wrong comparison if cheaper open models now offer a better cost-performance point. Another cluster of comments tied the thesis to everyday experience with coding agents that suddenly consume far more tokens once the task stops being toy-sized. The broader disagreement was whether rising frontier costs are a temporary market artifact or a structural feature of how these systems get better.

Average is all you need

Summary: This essay makes the deliberately irritating case that LLMs are making average work cheap, and that average is often enough to be economically transformative. The example is analytics and SQL: if a person can ask for a decent answer in English and receive a plausible table without commissioning a whole attribution project, then a lot of formerly expensive work has been pushed down to the baseline. The author is not claiming average is ideal. He is claiming average used to be scarce, and that scarcity disguised how much value even middling output can have.

HN Discussion: Database people pounced on the SQL example, warning that generated joins can silently multiply rows and yield polished nonsense. Others sharpened the critique by saying the real risk is not bad SQL itself but users who no longer know how to detect bad SQL. A different branch argued with the essay’s concept of average, invoking the old Air Force lesson that humans are rarely average across all dimensions at once.

Maine Said No to New Data Centers. Other States Are Racing to Follow

Summary: Mother Jones reports that Maine has passed a state-level moratorium on approving new hyperscale data centers, pausing projects above 20 megawatts while lawmakers argue over power prices, water usage, pollution, and the thinness of the promised local upside. What makes the story notable is the scale change. Opposition to AI infrastructure has moved from local zoning fights into statewide policy. The article’s real subject is not one facility in Maine, but the emerging politics of whether communities should absorb grid and resource costs for facilities whose benefits mostly accrue elsewhere.

HN Discussion: Commenters noted that anti-data-center votes can function as one of the few direct ways ordinary people can express anger at Big Tech. Another recurring point was that data centers simply do not create the kind of durable employment base that usually justifies major public concessions. The more constructive thread asked what package of taxes, noise limits, water protections, or community benefits could make these projects acceptable instead of automatically toxic.

The beginning of scarcity in AI

Summary: Tom Tunguz argues that AI has entered a supply-constrained phase in which compute access, not just model quality, becomes the binding strategic variable. He points to rising Blackwell rental prices, longer commitments from providers like CoreWeave, and the fact that even top labs are openly talking about not having enough compute for everything they want to pursue. The article sketches a market where frontier access becomes gated, latency worsens, and startups are forced toward smaller models or on-prem alternatives. It is a venture-style market read, but a specific one.

HN Discussion: Some readers thought scarcity would be healthy because it finally creates pressure to improve harness design and squeeze more out of small models. Others said AI-native businesses may discover they have dangerously little pricing power once model bills stop being subsidized by abundant cheap inference. The skeptical wing of the thread kept circling back to valuations, asking whether trillion-dollar expectations survive if the market pushes back against expensive model-dependent products.

---

History & Science

All 12 moonwalkers had “lunar hay fever” from dust smelling like gunpowder (2018)

Summary: ESA’s piece on lunar dust is one of those space stories that immediately becomes about materials science and human lungs rather than romance. Every Apollo moonwalker experienced some version of sneezing, irritation, or congestion after dust came back into the cabin, and the astronauts famously described the smell as burnt gunpowder. The article explains why this is not a trivial annoyance: lunar dust is sharp, clingy, abrasive, and chemically odd in ways that could matter a great deal for long-duration surface work. The next phase of Moon missions has to solve dust, not just rockets.

HN Discussion: Commenters dug into the gunpowder smell and explained it as material that had not previously interacted with oxygen suddenly doing so inside the spacecraft. The conversation then jumped to Mars, where perchlorates make surface contamination an even nastier human-factors problem, and to suit-docking concepts that keep contaminated gear outside the habitat. Another memorable set of replies quoted Apollo reports about dust jamming rover mechanisms and turning basic hardware into a maintenance problem.

Landmark ancient-genome study shows surprise acceleration of human evolution

Summary: Nature’s coverage of a 15,000-genome ancient-DNA study argues that human evolution did not slow to a crawl after prehistory, but in some ways accelerated after agriculture reshaped disease pressure, diet, and population structure. The paper tracks selection signals across western Eurasia and highlights genes tied to immunity, pigmentation, metabolism, and other traits with consequences that are still visible in present-day populations. The more combustible part of the paper is its suggestion that selection may also have touched highly complex traits. That is where the science story shades into a social one.

HN Discussion: Readers asked why humans, despite global spread and local adaptation, are not typically discussed in the same subspecies vocabulary often applied to other animals. Another branch focused on David Reich’s prominence in the field and whether ancient-DNA coverage has become too tightly associated with one research orbit. The most charged comments were about whether recent human adaptation is an obvious consequence of selection or a claim so entangled with politics that many people do not want to touch it.

Human Accelerated Region 1

Summary: HAR1 is one of the best-known examples of a genomic region that stayed highly conserved across species and then changed unusually quickly in humans. The region sits in overlapping non-coding RNA genes on chromosome 20, with HAR1A expressed in fetal Cajal-Retzius cells during a key window of brain development alongside reelin. That combination, rapid human-specific change plus a plausible neurodevelopment role, is what made HAR1 famous. It is the sort of compact biological fact that keeps reappearing whenever people discuss what might distinguish human brain development from that of other primates.

HN Discussion: The thread was small but nicely on topic. One reader asked whether there is a good atlas showing when genes turn on and off across a whole human life cycle, which is exactly the kind of context HAR1 makes you want. Another took the article as evidence that the human brain is not just a scaled-up primate brain but one with notable architectural modifications during development.

---

Academic & Research

The GNU libc atanh is correctly rounded

Summary: Even without full access to the paper itself, the title and surrounding thread make clear what the result is about: proving that glibc’s implementation of the inverse hyperbolic tangent now rounds correctly rather than merely staying within a small error bound. That is a more serious accomplishment than it sounds, because many math-library functions historically targeted approximate correctness, not exact IEEE-754 rounding on every input. For double precision, you cannot simply brute-force the whole space and call it done. This kind of result sits at the intersection of numerical analysis, careful implementation, and proof.

HN Discussion: Commenters did a good job explaining why correct rounding is a big deal, noting that “about one ULP” has long been an acceptable engineering target for libm. They also linked related floating-point resources, including a video about speedrun records that changed because atanh behavior changed over time. One smaller question was why the work lived on HAL instead of arXiv, which is an academic-distribution quibble but a real one.

Reflections on 30 years of HPC programming

Summary: Brad Chamberlain uses an anniversary keynote to look back at three decades of high-performance computing and ask why, despite dramatic hardware change, the field still largely writes code in the same languages. The essay’s mood is reflective rather than triumphant. It traces the repeated hope that a higher-level parallel language or model would finally break through, then measures that hope against the field’s stubborn attachment to established practice. What emerges is a portrait of HPC as a place where hardware keeps leaping forward while software culture changes cautiously, if at all.

HN Discussion: Experienced people in the thread were blunt: many new HPC languages fail because they do not attack the actual bottleneck, which is often memory bandwidth rather than syntax. Others suggested the field’s transient user base also matters, since many programmers leave after a PhD or a project and never build long-term pressure for ecosystem change. A third strand noted that plenty of cluster work already happens in very ordinary tools like Python, R, Perl, and awk, which complicates any neat story about elegant new parallel languages taking over.

---

Web & Infrastructure

How to Host a Blog on a Subdirectory Instead of a Subdomain (2025)

Summary: David Ma’s guide is exactly what the title claims only after you notice the hidden qualifier: it is a Cloudflare Workers recipe for serving a blog from a subdirectory on the main domain. The article argues that example.com/blog is better than blog.example.com for SEO and for keeping the site feeling like one property, then fills in the operational details that broad SEO advice usually skips. So the post is useful less because the underlying architecture is novel than because it spells out the proxying and routing work needed to make the choice real in a modern hosted setup.

HN Discussion: HN’s reaction was predictably prickly. Several people objected that subdirectory hosting is ancient, boring web-server behavior and that the title should have said “with Cloudflare Workers” up front. Others pushed back on the SEO premise altogether, saying they simply prefer subdomains or reject the article’s assumptions about how much consolidation matters.

Artifacts: Versioned storage that speaks Git

Summary: Cloudflare’s Artifacts is a Git-compatible storage service designed for a world where agents and automated sandboxes may need repos by the thousand. The launch post’s core claim is that source-control systems built for human developers do not map cleanly onto a world of programmatic repo creation, high fork volume, and ephemeral environments. Artifacts answers that by exposing repo creation, forking, credentials, and import flows through APIs and Workers primitives, while still speaking normal Git to ordinary clients. It is less “Git, but nicer” than “Git as infrastructure for machine-driven workflows.”

HN Discussion: The thread was strongest when it got concrete. People liked the API-first model and compared it to other machine-oriented Git backends, but also immediately worried about pricing, especially write-heavy usage compared with object storage. Another recurring point of excitement was the blobless-clone and partial-edit story, which feels well matched to agent sandboxes that need fast startup and narrowly scoped mutations.

Traders place $760M bet on falling oil ahead of Hormuz announcement

Summary: Reuters reports that traders sold roughly $760 million worth of Brent crude futures about 20 minutes before Iran’s foreign minister announced that the Strait of Hormuz was open. The article places that trade in a broader run of suspiciously well-timed oil bets during the current Middle East war, where public statements by states and militaries can move prices sharply. The story is less a markets explainer than a quiet insider-trading alarm. In a war-driven commodity market, advance knowledge of one announcement can look like a fortune.

HN Discussion: The thread focused first on source, with commenters saying that if the trade really reflected inside information, the leak was more likely to sit on the Iranian side than in Western markets. The next question was whether trades like this can be traced to actual beneficiaries or whether futures-market plumbing makes accountability too diffuse. Nobody spent much time on oil fundamentals, because the timing was the whole point.

---

Business & Industry

Making Wax Sealed Letters at Scale

Summary: Wax Letter turns what sounds like a boutique craft exercise into a fulfillment business: print the message, stamp wax with a custom seal, personalize the contents, and mail the whole thing in volume. The founder says the idea came out of trying outreach mailers and discovering that a wax seal changed response rates enough to justify operationalizing the flourish. What makes it interesting is not the romance of stationery, but the decision to productize a small ceremonial detail that normally resists scale. It is a tiny business built around manufactured tactile sincerity.

HN Discussion: The obvious question in the thread was “fine, but how do you actually scale wax sealing?” The founder answered with the detail everyone wanted, describing a Peltier-based cooling setup that helps harden wax fast enough to keep throughput up. The rest of the discussion oscillated between delight at the niche and ridicule for its expensive Victorian-marketing vibe.

I built a 3D printing business and ran it for 8 months

Summary: Wespiser’s business report begins with card stands for a neighbor’s trading-card auctions and ends with a clear-eyed account of why steady revenue is not the same thing as a scalable company. The post walks through design iteration, printing, packaging, local delivery, and the subtle way every single stage kept depending on the author’s own time. That is what gives the piece weight. It is not another maker success story or failure story, just an honest accounting of a business that worked operationally while failing the more brutal test of leverage.

HN Discussion: Commenters immediately attacked the economics, saying the published numbers looked far too generous to customers and far too stingy to the founder’s own labor and machine time. Others chimed in with their own one-person refurbishing or hobby businesses that make sense precisely because they stay small. The recurring advice was to price design, machine wear, throughput, and margin before concluding that repeat orders equal a healthy business.

Tesla tells HW3 owner to ‘be patient’ after 7 years of waiting for FSD

Summary: Electrek follows a Dutch Tesla owner who says HW3 customers are still being told to wait for Full Self-Driving years after paying for it and years after Tesla heavily implied that existing hardware would eventually support the feature. The article is framed around a collective Dutch claim effort rather than a one-off support gripe, which gives the story legal and consumer-protection weight. The underlying issue is simple enough: if a company sold a future capability as part of the product, how long can it keep extending the wait before that promise becomes indefensible?

HN Discussion: The thread split between cynicism and legal tactics. Some commenters argued buyers should try to unwind the original purchase agreement instead of waiting for technical salvation, while others pointed people toward the Dutch claim site and discussed whether similar cases could spread elsewhere in Europe. Underneath both was the same mood: disbelief that Tesla has managed to stretch this promise for so long.

---

Other

Casus Belli Engineering

Summary: Marcos Magueta’s essay gives a name to a pattern many engineers have seen but rarely formalized: a team uses a visible failure as pretext to destroy a system it already wanted replaced. The piece treats that move as a ritual of scapegoating, with the broken feature or missed commitment becoming the moral warrant for rewriting, replatforming, or purging a codebase. It is strongest when it describes the social mechanics of organizational blame, the way confidence collapses at the system level even when the fault is local. The grand theory is that some people learn to steer that process on purpose.

HN Discussion: Reactions were mixed in a way that almost proved the author’s point about narrative. Some readers thought the Girard-inflected language overstated a phenomenon that can be explained more plainly by incentives and politics. Others distrusted the essay’s tone altogether, saying it read inflated or even machine-generated, while a third group argued that engineering cannot be neatly separated from social theater because organizations really do make technical decisions by way of blame and impression management.

Random musings: 80s hardware, cyberdecks

Summary: This essay is nostalgia in the best sense, because it uses the memory of 1980s computer weirdness to say something concrete about today’s hardware monoculture. The author misses the feeling that each machine family and each shop had its own personality, then ties that feeling to building a cyberdeck as a modern way to recover some of that individuality. The cyberdeck matters less as a practical computer than as a protest against standardized slabs and interchangeable retail. It is a hobbyist manifesto for bespoke computing.

HN Discussion: Builders in the thread described cyberdecks as ideal one-off projects precisely because they reward improvisation, scavenging, and lopsided personal taste. Another commenter compared the fantasy to visiting Shenzhen and finding not a cyberpunk bazaar but rows of near-identical gadgets, which fit the article’s complaint exactly. A nice third theme was that cyberdecks feel like a revival of hacker tinkering without some of the self-serious baggage that maker culture can accumulate.

There is no you in your brain – your identity is a “society of the mind”

Summary: Big Think’s piece repackages a familiar but still unsettling idea: the self is not a little executive inside your head, but an emergent arrangement of many interacting processes that can change over time. The “society of mind” framing gives the article its shape, treating identity as something negotiated among subsystems rather than housed in one privileged center. It is a popular essay rather than original research, but it does a good job of making the philosophical consequence feel personal. If there is no single “you” in the brain, continuity starts looking more constructed than discovered.

HN Discussion: The short thread immediately turned philosophical. One commenter linked the idea to Simondon’s account of psychic individuation, while another asked the obvious stress-test question: if the self is distributed, what exactly is ego death? The conversation never got large, but it stayed tightly attached to the article’s actual claim instead of drifting into generic neuroscience chatter.

Footer

That’s the morning set: 30 fresh stories, with the strongest throughline being systems that look simple until you inspect the hidden structure underneath them. The WhatsApp destination requested by the task is Andy (+447861388869), and the deployed URL should be: https://hn.due.io/blog/hn-morning-brief-2026-04-18/