The 4-Desktop Cognitive Firewall — KWin Rules That Killed My Context Switch Loop

Waiting on builds is when the damage happens. A reflexive browser tab switch breaks the sequential focus loop. Here is the KDE KWin rule configuration that locks the distraction out.

Why Isn't My Static Site Build Instant? An Architectural Deep Dive

Ever wondered why static site generation takes seconds or minutes instead of milliseconds? It's easy to blame Clojure or Babashka, but the true bottleneck is often the operating system's process boundary. Let's explore subprocess overhead, compiled vs. interpreted languages, and how to achieve sub-millisecond builds.

React is Done: The Systems Shift in Web Frontend

React's API has stabilized, leading many to believe frontend is a solved problem. But client-side view rendering is merely a commodity now—the true battleground has shifted to systems-level compilers, hydration serialization, and collapsing the network boundary.

The P2P Job Market — Dumb Idea or Inevitable?

An honest exploration of a decentralized job market where agents talk directly to companies without browsers — like BitTorrent for applications.

The Oracle Singapore Needs But Won't Build

Instead of merging WDA and SSG into another bureaucratic layer, Singapore should have built a centralized AI Oracle—forked from GLM 5.2, fronted by Singpass, serving every citizen. Here's why they didn't and why they're wrong.

Headhunter-Agent: Full Tech Stack of a Local-First Multi-Agent System

A deep dive into the full tech stack of headhunter-agent — a local-first, privacy-preserving multi-agent system for job hunting built in Clojure.

Applying Agile and Scrum to a Solo Open-Source MAS Project — A Mentor's Guide

A mentor's walkthrough on how to apply the Agile and Scrum principles from the PDWD-APM-0226 bootcamp to the headhunter-agent multi-agent system project, with D2 architecture diagrams.

Static Blog vs WordPress — A Real-World Comparison

My blog runs on a Babashka static site generator deployed to GitHub Pages. Here's how it compares to WordPress across cost, performance, maintenance, and workflow.

The Future Stack — UI, Inference, Database

What if the traditional backend (REST APIs, business logic, middleware) gets absorbed by inference, leaving only UI, an LLM, and a database?

The Entropy Collapse Thesis — Why One Tool, Why Clojure, Why LLMs as Compiler

One engineer's argument for minimizing cognitive entropy by collapsing the toolchain into the smallest possible surface area — Clojure/Babashka as the substrate, LLMs as the compiler, and why inheritance is a design violation.

LLM Cognition Is Sequential, Not Parallel

An LLM describes its own cognitive architecture — token by token, one path at a time, no true parallelism or lateral leaps, just sequential prediction with attention context.

What Hyperliquid Got Right — And Why BSV Already Has It Natively

Hyperliquid built a custom L1 because no existing chain could handle on-chain order book throughput. But BSV with Chronicle and Teranode removes that constraint — and adds protocol-level composability no app-chain can match.

How Do You "Think"? — An LLM Maps the Gap Between Statistical Prediction and Human Cognition

A detailed architectural comparison between LLM and human cognition with visual diagrams — token-by-token prediction versus parallel, embodied, self-aware consciousness.

BSV is Bitcoin: The 16-Year Restoration of Satoshi's v0.1 Protocol

A forensic comparison of Bitcoin SV against Satoshi Nakamoto's original v0.1 design using measurable criteria: opcodes restored, block size, fee model, transaction digest, and protocol stability.

Bitcoin Was Designed to Leverage IPv6: The Lost Architecture

Bitcoin's whitepaper describes IP-to-IP transactions as the primary payment method — removed in 2011 by BTC Core. The deep architectural parallels between Bitcoin's transaction format and IPv6 headers, CGA addressing, and what it reveals about the original design team.

Bitcoin Is Composable: Indelible, Agent Memory, and the Internet of Agents

Bitcoin's OP_RETURN makes it the most composable base layer in existence. Indelible, COT1, BRC standards, and overlay networks all compose on the same transaction graph. This is how the Internet of Agents actually gets built.

The BSV Agent Coordination Layer: A Visual Architecture

The Recursive Self-Improvement Illusion: AI's Hidden Human Scaffold

A deep dive into the "Recursive Self-Improvement" myth in modern AI, analyzing why LLMs depend on scraping the collective troubleshooting labor of human developers to appear smarter.

The Decentralization Paradox: Wallet Downtime and Indexer Monopolies

Why my "non-custodial" wallet went blind, analyzing the heavy indexer bottlenecks in modern UTXO and account-based networks, and setting up the architectural comparison between BSV, BTC, Ethereum, and Solana.

Solana vs. Bitcoin SV: Two Approaches to Monolithic L1 Scaling

A deep systems engineering comparison of monolithic L1 scaling: dissecting Solana's account-based parallel execution (Sealevel) against Bitcoin SV's UTXO parallelism and database state designs.

Sandbox vs. Keyring: Understanding Credential Precedence in Developer Security

How scoped environment variables override local keyrings in sandboxed environments, why this design protects developer secrets, and how to navigate credentials securely.

Zero-Backend Analytics: Collapsing Web Tracking to Postgres and GCP for $0

Why I rejected bloated SaaS trackers, isolated my database boundaries, and built a custom static blog analytics pipeline using only Neon Postgres and GCP Cloud Functions for $0.

Scaling Micro-Transactions: Many-to-One Payout Batching inside Postgres

How to implement threshold-based payout batching using many-to-one database relations and PL/pgSQL triggers to minimize on-chain notary fees and transaction costs.

Offline Execution: The Only Economic Moat in the Age of Generative Imitation

A deep dive into the architecture of lagu-lagu—our no-backend, stateless payout registry—and why human-grade offline execution is the only moat that LLMs cannot copy.

Leaky Layout Abstractions: Fixing Template Scope Leaks in Static Site Compilers

A technical post-mortem on how custom standalone layouts leak unparsed compiler directives to the client, and how to resolve it at the pipeline layer without dependency bloat.

Decentralization & Governance: Comparing BTC, BSV, XCH, Linux, and the JVM

A deep comparative analysis of decentralization models: dissecting how Bitcoin (BTC), Bitcoin SV (BSV), Chia (XCH), the Linux Kernel, and the JVM manage updates, code consensus, and power.

Engineering Spec: Decoupled Zero-Cost Blog Analytics

The complete technical specification, schema design, and serverless code for our isolated blog analytics tracking engine.

Decoupled Static Dashboards: Building Transparent roadmaps in Public

How to build and serve interactive, public project roadmaps natively to readers at zero compute cost using static compiler pipelines.

Clojure & Bitcoin: Building a Sovereign Node & Integration Sandbox

An engineering overview of integrating Clojure with a native Bitcoin node RPC, sanitizing UTXO wallet outputs from SQLite, and using Malli schema validation for data safety.

Taming LLM Repetition Loops & Building aur-audit for the AUR Security Incident

A security engineering guide on why smaller LLMs get caught in repetition loops during agentic workflows, how to mitigate it, and the release of aur-audit—a Clojure (Babashka) static analyzer responding to the active June 2026 AUR security incident.

Red Teaming AI Pipelines: How Attackers Weaponize LLMs & How to Build Defensive Harnesses

A deep dive into how threat actors use large language models for vulnerability generation and polymorphic evasion, and how security engineers construct automated test harnesses to mitigate agentic risk.

Quickblog: The Zen of Minimalist Static Site Generation

An architectural breakdown of Quickblog, the minimalist static site generator powered by Babashka, and why zero-database static HTML is the ultimate design choice.

AI-First SDLC: Designing for High Velocity and Cognitive Vertigo

An engineering guide to the AI-First Software Development Lifecycle (SDLC). Learn how to structure agent interactions, build validation boundaries, and survive the literal cognitive fatigue of developing at warp speed.