Mathematical Determinism: Overcoming the Lisp Parenthesis Odyssey in Production

When a standard container build compiles successfully but triggers a production HTTP 503 Upstream Connection Failure, trial-and-error debugging fails. Here is how we isolated temporal telemetry and used string-aware static analysis to achieve absolute AST balance.

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.

Gotong Royong — Nusantara Resource Allocation Engine, Refactored

The Gotong Royong Local Resource Abstraction Engine has been refactored to embed Nusantara cultural constraints — anti-hoarding velocity mechanics, Small-World/Mandala network topology, and indigenous linguistic layers (Sambatan, Mapalus, Ngayah). This post documents the architectural decisions.

REPL vs nREPL — Why Clojure's Live Programming Is a Superpower

Deep technical dive into the REPL and nREPL — how they work at the protocol level, why Clojure's architecture enables live programming, and how every other language ecosystem falls short. With D2 diagrams.

Designing a Machine-to-Machine Job Application Protocol

A deep dive into the M2M Job Application Protocol — eliminating browsers, CAPTCHAs, and manual portals from the recruiting pipeline using JSON-LD schemas, decentralized discovery via DNS, Ed25519 cryptographic identity, and signed application packages built with Clojure and Babashka.

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.

Building an AI Butler: A Post-Mortem From Inside the Architecture

I shipped a Hermes-class personal AI butler in Clojure/Babashka. Five risks hit me while building. Three had architectural fixes. Two did not. Vector at the end.

Scrum for a Solo Open-Source Project — Building Butler

Applying the 2020 Scrum Guide to a solo open-source Clojure project. Roles, events, artifacts, and the Product Backlog for the Butler — from someone learning this in class and building it in real time.

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.

pdpa-sg-clj: Compliance-as-Code for Singapore's PDPA, Readable by AI Agents

A new public Clojure + Babashka toolkit that turns the 11 Singapore PDPA obligations into a self-ticking checklist, a Mod-11 NRIC redactor, and a ripgrep-backed scanner an AI agent can read end-to-end.

The Paperclip Engine: A Deterministic Business Kernel in Clojure

Building, Fixing, Cleaning, and Publishing

A full-session retrospective — research, curation, code, bugfixes, PDPA compliance, and building a complete insurance platform for AI agents on BSV.

From Simulation to Settlement: Live Testnet BSV for AI Agents

Debugging a Missing Blog Post — Quickblog Cache & YAML Frontmatter

How a missing blog post revealed a silent cache bug and a YAML format incompatibility that crashes quickblog's tag generation.

The BSV Agent Coordination Layer: A Visual Architecture

One Language. One Ledger. How Clojure + BSV Is All You Need for Sovereign AI Agents

From Python to Babashka: Rewriting a Crypto ETL Pipeline in Clojure

A hands-on walkthrough of porting a Python + SQLite crypto price tracker to Babashka (Clojure scripting runtime) — covering the ETL design, the JDBC trap I hit, and why shelling out to sqlite3 turned out to be the cleanest solution.

How a Single ".env" in allowed-extensions Could Leak Your Secrets to LLMs

A three-layer defense-in-depth fix for an AI context bundler that was accidentally including .env files in LLM context.

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.

Designing a Zero-Configuration, Zero-Admin Developer Sandbox for Career-Switchers

How to build a zero-configuration, zero-administrator local development environment running Django and React on Windows 11 to help adult tech-learners bypass environment installation friction.

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.

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.

Quickblog Gotcha: Why Your Post Titles Are Displaying Twice

A quick troubleshooting guide on how Quickblog handles title metadata rendering, and how to programmatically resolve double H1 headers.

How to Maximize Clojure Usage & Minimize Token Quota on Antigravity IDE

A guide on managing token quotas and optimizing LLM usage for Clojure development in Antigravity.

Bitcoin v0.1 Set in Stone: Building a functional blockchain toolkit in Clojure

A deep dive into bsv-clj, a Clojure toolkit built to explore Bitcoin's original, immutable protocol design through a JSON-RPC client, wallet toolkit, and custom block explorer.

The Browser is Fragile: Why I Nuked My Web GUI for Native Clojure Desktop

I tried building headhunter-agent as a web app. It broke. In minutes, I nuked the browser code and rewrote it as a native cljfx desktop app. Here is why.

Hello Clojure!

Welcome to my Clojure automation journal, hosted natively using Babashka and Quickblog.