Linkfest #2

A curated escape from the feed: My latest selection of links that sparked a second thought. 

This edition jumps between very old time scales and very current AI topics. There is a hidden astronomical clock in a concrete dam, a reminder that engineers once thought in millennia. Several pieces circle around AI and software work, some sober, some frustrated, some quietly optimistic. There is also a strong theme of complexity: why it keeps growing, why we add instead of remove, and why tools that promise simplicity often just move the hard parts around. Mixed in are a few very practical reads on security, HTML, PHP architecture, and one Linux idea that is slightly weird.

Enjoy! -- Christoph (CTO @ Basilicom)

Cerebras and the Case for a Giant Chip

https://spectrum.ieee.org/cerebrass-giant-chip-will-smash-deep-learnings-speed-barrier

This IEEE Spectrum piece explains Cerebras's wafer-scale processor, a single chip the size of an entire silicon wafer. Instead of clustering many GPUs, the company puts compute, memory, and interconnects on one massive piece of silicon to speed up neural network training. The article covers both the technical challenges and why this approach was considered unrealistic for decades.

It is refreshing to read about hardware ambition again, not just software layers on top of existing chips. Whether this becomes mainstream or stays niche, it shows that performance limits are still being challenged at very low levels.

AI Tools Meet Reality in an Accessibility Project

https://blog.mayflower.de/24585-claude-code-meets-lovable.html

This German-language post documents a real project built with two AI tools, one for backend code and one for frontend. The author tries to create a WCAG accessibility scanner and carefully describes where things worked fast and where everything fell apart. The main issue was coordination: the tools could not see or understand each other's output, leading to long debugging sessions and wrong assumptions.

I appreciate how concrete this is. No hype, no panic, just a detailed account of friction. It is a good reminder that speed in the first hours often hides costs later, especially when systems lose shared context.

The 26,000-Year Clock Inside Hoover Dam

https://longnow.org/ideas/the-26000-year-astronomical-monument-hidden-in-plain-sight/

This article uncovers a largely ignored monument at Hoover Dam: a terrazzo floor that encodes Earth's axial precession and pins the dam's construction to a specific moment in a 26,000-year cycle. It explains how the artist used star positions, planets, and the slow wobble of Earth's axis to create a frozen astronomical timestamp. The piece also documents how little institutional memory remains about the monument and how much effort it took to reconstruct its intent from archives and drawings.

I like this because it shows a kind of engineering confidence we rarely see today. Someone assumed that people far in the future might still care to decode this. It also quietly asks what we choose to explain and preserve and what we let fade into obscurity even when it is literally set in stone.

Why We Keep Trying to Replace Developers

https://www.caimito.net/en/blog/2025/12/07/the-recurring-dream-of-replacing-developers.html

This is a long look back at 50 years of attempts to make software development so easy that specialists would no longer be needed. From COBOL to CASE tools, from Visual Basic to low-code and now AI, the same promise keeps returning. The author walks through each wave and shows how the tools changed workflows but never removed the need to reason about edge cases, systems, and trade-offs.

This is useful context for anyone currently feeling pressure to believe that AI will make teams obsolete. The pattern is familiar, and that does not mean new tools are useless. It just means the hard part has always been thinking, not typing. Text is in German!

You Do Not Have to Close Every HTML Tag

https://blog.novalistic.com/archives/2017/08/optional-end-tags-in-html/

This article patiently explains that many HTML tags do not require closing tags and never have. It traces the confusion back to XHTML and years of copied misinformation. The author goes deep into specs, browser behavior, and the difference between valid HTML and personal style preferences.

This is one of those posts that saves time by being very clear. It is not about encouraging sloppy code, but about understanding the rules before enforcing habits. 

Code Is Cheap, Software Is Not

https://www.chrisgregori.dev/opinion/code-is-cheap-now-software-isnt

The author argues that AI has dramatically lowered the cost of producing code, but not the cost of building software that survives real use. He describes a shift toward personal, disposable tools and explains why distribution, maintenance, and judgment remain hard problems. Much of the current excitement, he suggests, confuses demos with durable products.

This aligns strongly with agency work. Clients rarely pay for code, they pay for outcomes that keep working. Faster code generation helps, but it does not replace responsibility for decisions.

Why We Add Instead of Subtract

https://www.ufried.com/blog/addition_bias/

This post explores research showing that people tend to solve problems by adding things rather than removing them. Under stress and cognitive load, this bias becomes stronger. The author connects this to IT systems, where new tools, layers, and processes accumulate while old ones rarely disappear.

This is a useful lens for architecture discussions. Many problems feel urgent, and adding feels safer than removing. Naming the bias does not fix it, but it makes better questions possible.

Testing PHP Architecture with PHPArkitect

https://jeandaviddaviet.fr/en/php/discovering-phparkitect-testing-php-code-architecture

This article introduces PHPArkitect, a tool that lets teams write tests for architectural rules instead of relying on conventions and reviews alone. The author shows how to enforce patterns like invokable controllers or readonly DTOs and how easy it is to extend the tool with custom rules.

I like tools that make implicit expectations explicit. Architecture tests will not replace thinking, but they can reduce friction in teams and keep discussions focused on intent instead of habits.

Loss32: A Linux Built Around Windows Binaries

https://www.theregister.com/2026/01/06/loss32_crazy_or_inspired/

This Register article covers Loss32, a proposal for a Linux system where the entire user environment runs inside Wine. Instead of Linux hosting Windows apps, Windows binaries become the main interface. The piece places the idea in a long history of compatibility projects and half-forgotten experiments.

I am not sure this is a good idea, but someone is thinking it through seriously. It challenges assumptions about where stability really comes from and what users actually depend on.