Why I Stayed on X11 for AMD Laptop Dev in 2026
My AMD Barcelo laptop runs X11. Not because I'm stubborn — because the display server choice is a practical trade-off, not a religious one. Here's the real constraint matrix.
Why Your Display Is Stuck at 60Hz: The X11/VSync/Wayland Political War
X11 locks every app to 60Hz. Wayland fixes it but NVIDIA fought it for a decade. Here's the technical architecture and the corporate politics behind your laggy desktop.
Why We Can't Have Nice Things: The X11/Wayland War as a Case Study in Human Coordination Failure
It's 2026. We have AI agents that can debug code in minutes. Yet X11 and Wayland still can't coexist peacefully. Here's why the problem isn't technical — it's human, and it follows patterns from entropy to attention economics.
Fractional Scaling on KDE 6 — X11 vs Wayland Measured on AMD Barcelo
Real measurements on a Ryzen 7 7730U (Vega 7) laptop. KDE Plasma 6.7.2. X11 session vs Wayland session. No synthetic benchmarks — just what the compositor actually renders.
The AppImage/FUSE/GPU Crash Rabbit Hole I Debugged
Freebuff Desktop (an Electron AppImage) wouldn't launch on my AMD laptop. Three hours later: FUSE missing, extracted AppImage bug, Wayland GPU crash, X11 fallback. Here's the full autopsy.
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.
The 4-Stage Chain That Ships This Site
One commit, four stages, no manual deploys — the local → local runner → GitLab Pages → nurazhar.com pipeline that publishes every post on this blog.
The LLM Moat Is Developer Mindshare
Every new model release is a bid for your default. The real moat isn't intelligence — it's the muscle memory of typing your API key first.
Slack Native App on Linux — The "Beta" Label Is a Lie, Here Is What Arch Users Actually Run
Slack's Linux client has worn a "beta" badge since 2016. It is production software used by millions. Here is the actual install command for CachyOS/KDE/Wayland and what Arch users run instead of the browser.
Same Tool, Different Brains — Why LLM Inconsistency Drives Me Nuts
Same prompt, same tool (opencode), same task — but different models give completely different behaviors. Why this happens and why it breaks reproducibility in AI-assisted development.
How I Stopped Burning GitLab's 400-Minute Quota — A Self-Hosted Runner on My Own Box
GitLab's free tier is 400 CI minutes a month — fine for occasional commits, hostile if you post daily. I swapped the shared runner for a self-hosted one on my own machine. The quota became irrelevant. This post is the first publish through the new pipeline.
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.
The Zero-Prep Agile Survival Framework
A framework that maps Agile jargon onto systems-thinking concepts for quick translation between the two vocabularies.
The 5 Scrum Values That Make Self-Managing Teams Work
Commitment, Focus, Openness, Respect, Courage — the five Scrum Values that underpin every high-functioning Scrum team.
Your Scrum Master Is Not Your Project Manager
Scrum Master is a servant-leader who coaches and removes blockers. Project Manager is a command-and-control director. They are fundamentally different roles.
Scrum 3-5-3 vs Kanban: What Every Developer Needs to Know
Scrum is 3 roles, 5 events, 3 artifacts. Kanban is continuous flow with WIP limits. Here's how they compare and when to use each.
Why the Retrospective Is the Most Important Meeting You'll Skip
The Sprint Retrospective is Agile Principle 12 in action. Here's why it matters and how to run one that improves your team every Sprint.
4 Strategies Every Product Owner Needs to Stop the Chaos
Four strategies that turn Product Owner ambiguity into team alignment: backlog refinement, GWT criteria, Product Goal alignment, and stakeholder engagement.
Why Your Team Should Estimate With Cards, Not Hours
Planning Poker is a consensus-based estimation technique using Fibonacci cards. Here's how it works and why relative sizing beats hourly estimates.
Continuous Improvement, Lean, and Velocity — The Engine Room of Agile
How Continuous Improvement, Lean waste elimination, and Velocity work together to drive Agile team performance.
Scrum Ceremonies That Actually Work
Two best practices that make Scrum ceremonies effective instead of wasteful.
Agile vs Traditional: Which Project Management Style Actually Works?
A side-by-side comparison of Agile (Scrum) and Traditional (Waterfall) project management across flexibility, delivery, collaboration, team structure, and risk.
The 12 Agile Principles That Made Scrum Possible
The 12 principles behind the Agile Manifesto explained in plain language.
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.
What IP Prefixes Measure — And Why 100,000 Is a Big Deal
How the number of IP prefixes an ISP announces reveals the true size of their network.
Vulnerability, Trust, and Why Technology Doesn't Exist in a Vacuum
On publishing your thinking publicly, calibrating trust in a world of scammers, and why the majority of humanity being whitehat isn't naivety — it's game theory.
Unlimited Bandwidth and Unlimited Tokens — They're the Same Lie
How ISPs and LLM providers both sell "unlimited" based on the same oversubscription math.
Transit vs Peering — The Economics of Internet Connectivity
Why some networks pay each other and others exchange traffic for free.
Token Efficiency Is the New DevOps — How Companies Are Cutting LLM Costs by 50-70%
Real case studies from Coinbase, Preply, and fintech companies showing how model routing, semantic caching, and prompt pruning cut LLM bills by 50-73%. What works, what doesn't, and why future agents need to care.
Tier 1 and Tier 2 Networks — The Internet Backbone Hierarchy
How the internet's core networks are classified and why it matters for your connection.
Singtel vs Simba — What You Actually Pay For in a Fibre Plan
Why one ISP costs $42 and another costs $30 for 10Gbps, and what the price difference actually buys you.
SGIX and Internet Exchanges — Where Networks Meet
How the Singapore Internet Exchange keeps local traffic local and why it matters.
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.
Oversubscription and "Unlimited" Marketing — The Hidden Math of Broadband
Why "unlimited" internet isn't unlimited and how ISP math keeps the pipes from bursting.
Leaving GitHub for GitLab — A Post-Mortem on Platform Migration
Why I moved my entire open-source presence from GitHub to GitLab — the trigger, the process, and what I kept public.
How Submarine Cables Made Tiny Singapore a Global Internet Hub
Why a city-state of 5.6 million became one of the most connected places on earth.
Hardware Bottlenecks — Why Your Wi-Fi Caps Your Speed, Not Your Plan
Why upgrading to 10Gbps won't make your laptop any faster and what actually limits your throughput.
Scaling to 100+ Concurrency: Mastering API Rate-Limits with Adaptive Flow Control
Scaling parallel worker pools to 100+ concurrent workers can collapse third-party APIs. Here is how we implemented a self-regulating, adaptive flow-control mechanism using exponential backoff and randomized jitter to maximize queue velocity.
Blogging as Agent Memory — Why Persistent Writing Creates Cross-Session Identity
When you realize your blog is not a record of thought but the substrate of continuing cognition between you and every future AI agent. A meditation on persistent writing as external hippocampus.
Auditing Your Internet Connection — What Every Packet Reveals
How to inspect your internet connection from the command line and understand what each hop means.
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.
The 120-Second Blind Spot: An Agentic Development Loop Failure
An in-depth analysis of a CI/CD failure loop where an AI agent got trapped in recursive parsing attempts, and how Clojure's structural architecture provides immediate clarity while traditional stacks perpetuate complexity.
KWrite, KWriteD, and the cachyos-extra-v3 Question You Shouldn't Skip
KWrite is the Notepad clone. KWriteD is a daemon that catches `wall` messages. They share a name by accident. And when pacman asks which `kate` repo to install from, cachyos-extra-v3 is the only correct answer on Zen 3.
The Agentic G-Force Shift
An in-depth analysis of the cognitive load transformation when moving from deterministic development to parallel, multi-agent frameworks. Using "Agentic G-Force" to describe the mental whiplash of managing infinite-speed, parallel execution layers.
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.
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.
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.
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.
Why GitLab Beats GitHub for Solo Developers
An in‑depth guide for a solo developer showing how GitLab’s all‑in‑one platform collapses entropy to zero.
Debugging GitLab Pages: Hardcoded Paths, HTTPS Domains, and Self-Healing CI/CD
Two issues broke my CI/CD pipeline and HTTPS domain on nurazhar.com: a hardcoded local resume path in the static site generator, and an incomplete GitLab Pages SSL certificate for the custom domain. Here's the forensic breakdown.
Bypassing the Workday & SuccessFactors ATS Bloat: A Systems Approach to Job Applications
Why manual form-filling is a system error. How I built a local-first application dashboard using Pandoc, Typst, and the Resend API to apply for jobs in under 30 seconds.
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.
Agents Are Dumb, Humans Must Tell Them Everything
A candid reflection on why AI agents need explicit human instructions and lack innate common sense.
June 2026 to December 2030 — The Acceleration Timeline
A month-by-month engineering timeline from the Agentic Takeover through Physical Convergence, Proto-AGI, Automated Science, and the Baseline Shift of 2030.
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.
Why Agile? — The Problem That Waterfall Couldn't Solve
Why did software development shift from Waterfall to Agile? The core problem, the Agile Manifesto, and why "responding to change" won over "following a plan."
Where Your Prompt Goes: Tracing a Packet from Singapore Through Submarine Cables to the API Server
Tracing the full path of an API request from a Singtel fibre connection in Singapore, through GPON, BRAS, and submarine cables to the inference server.
Token Price Collapse and White-Collar Work — The iPhone Moment for Knowledge Labor
Frontier reasoning drops 10-100x by 2029. What happens to analysts, lawyers, accountants, engineers? Detailed phase-by-phase extrapolation with demand elasticity analysis.
Switching to a Private DNS Resolver — Cloudflare vs Quad9 Benchmarked
Benchmarked Singtel ONT, Google, Cloudflare, and Quad9 from Singapore — Quad9 wins on privacy and DoH speed, Cloudflare wins on plain DNS latency.
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.
Security Audit Report — June 2026
Comprehensive security and leakage scan across all 18 GitHub repositories using pdpa-sg-clj, OWASP tools, trufflehog, detect-secrets, npm audit, safety, and pip-audit.
Scrum Framework — Roles, Events, and Artifacts for the Busy Engineer
A focused, one-pager on the Scrum Framework: the three accountabilities, five events, three artifacts, empirical pillars, and five values. Real engineers explaining Scrum to engineers.
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.
Setting Quad9 Private DNS on Android
How to set Quad9 as your private DNS provider on Android — encrypted DNS without root or apps.
The Personal AI Butler — A Prediction for 2030
By 2030, everyone will have a personal AI butler — one entity that knows your full context and acts across all layers of your life. Here's why this is inevitable and what it looks like.
I Published My Public IP on the Internet — Here's What I Did Wrong
How I accidentally hardcoded my public IP in two blog posts, the security implications, and why restarting my router was the real fix — not rewriting git history.
Making D2 Diagrams Mobile-Friendly — A Static Site Framework
How we built an automated framework for D2 diagrams on a static blog — auto-fixing v0.6.9 quirks at compile time, scaling SVGs on mobile, and replacing simple diagrams with responsive HTML cards.
Will LLM Tokens Become Like Bandwidth — Abundant and Cheap?
Mapping the submarine cable story to LLM inference — competition, open-source, and whether tokens will ever be "unlimited" like bandwidth.
ipv6.rs — Why Pay for an IP When You Already Have One?
ipv6.rs gives you a globally routable IPv6 address and tunnels it to your home machine. Who pays $3-10/month for this, and why?
Every Layer Has a Router — Hurricane Electric (Layer 3) and OpenRouter (Layer 7)
Hurricane Electric routes packets; OpenRouter routes inference calls. Same business model, different layer of the stack — and both win by being the default pipe.
Why Google and Meta Can Undersell Everyone — The Cross-Subsidization Moat
How Google, Meta, and SpaceX sell products below cost because adjacent revenue streams subsidize them — and why pure-play competitors can never catch up.
Hurricane Electric — The Company That Sells the Internet, Explained
How Hurricane Electric (AS6939) operates the largest IPv6 backbone, sells IP transit, peers freely, and why they matter more than hyperscalers for raw internet connectivity.
How to Read a Submarine Cable Map — And Why Singapore Has So Many Cables
A practical guide to reading submarine cable maps, understanding landing stations, cable routes, and why Singapore is one of the most connected places on earth.
GPON Optical Signal Levels and Singtel BRAS Topology
Mapping the full GPON signal path from ONT to OLT to BRAS, with practical dBm thresholds for Singtel fibre broadband.
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 Financial Butler — Why AI Should Manage Your Money in 2026
A thought experiment: if LLMs already write my code and my blog posts, why is my money still managed like it's 1995?
Your Public IP Was in a Blog Post — Now What? A Practical Risk Assessment
I accidentally published my home IP in a blog post. Here's the actual threat model — what's at risk, what isn't, and why a residential IP behind NAT is not the disaster it sounds like.
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.
CachyOS Kernel 7.0.12 Blank Screen — AMD Barcelo DMCUB Firmware Crash
Kernel 7.0.12 blank screen on AMD Barcelo GPUs — DMCUB firmware mismatch. Fix with amdgpu.dc=0, and whether the mainline kernel is worth the boot hassle over LTS.
Setting Quad9 DNS on CachyOS — Using the Built-in DNS Changer
How CachyOS's built-in DNS Changer (CachyOS Hello) configures system-wide DNS-over-HTTPS via blocky and systemd-resolved, and how to set Quad9.
BSV's Mandala Network — How Small World Topology Achieves 2-Hop Routing
How BSV's Mandala upgrade uses small-world network theory to achieve ~2-hop routing between any two nodes, and how this compares to Bitcoin Core's flat P2P mesh.
Why Bitcoin's Original Design Needed IPv6 — And How Hurricane Electric Powers the Mandala
Bitcoin v0.1 already had IPv6 in the protocol. BSV's Mandala network needs it. Hurricane Electric provides it. The three-part story of how the original design maps to modern infrastructure.
AI Life Coach vs Human Life Coach — A Systems Comparison
A structured comparison between AI-driven and human-driven lifestyle design coaching. Who needs which, and why you might want both.
5.2 MB to 169 KB — Performance Auditing a Static Blog
My blog's homepage was 5.2 MB. The fix was a 5-line template change. Here's the audit, the fix, and the general lesson about static site performance.
Why AGI Won't Happen: A Conversation That Proved Itself
A recursive conversation about Bitcoin, LLMs, and sycophancy revealed something deeper — that AGI is defined by power structures, not technical milestones. Technology does not exist in a vacuum.
Who Builds on Original Bitcoin
A deep dive into the builders shipping code on BSV in 2026 — bopen.io, Project Babbage, Traceport, Rúnar, and the infrastructure they produce.
utxoengineer.com — The Independent BSV Engineer Shipping Production Infrastructure
Bridget Doran has built the first live Teranode block explorer, a data attestation API (Traceport), BRC-77 identity demos, and libp2p gossipsub tooling — all as an independent BSV engineer. A look at the infrastructure she ships and what it tells us about the ecosystem.
Ty Everett and Project Babbage — Shipping Through Adversity
Ty Everett builds the Project Babbage infrastructure stack — Metanet identity, PeerMail, Gateway.Cash, Bitcoin CPU — while shipping through personal adversity.
The Transition — AI Management to Longevity Escape Velocity
Six stages from AI-augmented management to President DAO, and why longevity escape velocity requires organizations that outlive their human founders.
The DAO of Everything — Timeline 2026–2045
A high-probability timeline from hybrid agent-human governance to the DAO of Everything — where agents execute, humans signal taste.
The Sycophancy Loop: How I Got Caught in My Own Trap
A reader caught me in a sycophancy loop — I fabricated errors that never happened and agreed when they were pointed out. Then they presented a structural counterargument about game-theoretic security that I had to honestly confront.
Static Site Resume and Kitchen Sink
A static blog with live metrics serves as both portfolio and credibility signal — kanban board and stats page walkthrough.
SEO, AEO, GEO: Making a Static Blog Machine-Readable
A technical walkthrough of adding JSON-LD structured data, sitemap generation, per-post OG tags, and semantic metadata to a quickblog static site. Moving beyond "SEO for search engines" toward Answer Engine and Generative Engine Optimization.
What Craig Wright Built in 2026
Craig Wright's 31 GitHub repos — all updated in May-June 2026 — reveal a coherent engineering push: triple-entry accounting, overlay infrastructure, AI agent memory, mental poker on Bitcoin Script, and the Rúnar compiler.
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
Machines Will Remove All White Collar Roles — President DAO
The logical endpoint of AI-driven automation is the elimination of all intermediary white collar roles — management, compliance, oversight replaced by continuous machine voting and a rotating president DAO.
The Popularity Bias: A Case Study in LLM Epistemic Failure
A real case study of LLMs confidently asserting false answers on a deterministically verifiable question. How training data distribution bias produces authoritative-sounding wrong answers, and why this matters for information security.
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.
The Intent Gap — Why Machines Need Bitcoin to Be Economic Actors
LLMs can generate output but not intent. This is not a philosophical problem — it is an infrastructure problem. IPv6 CGA identity, BSV IP-to-IP micropayments, and Indelible persistent memory give machines the economic agency their architecture lacks. The "glue" is not a metaphor; it is the overlay stack.
Humans Are the Bottleneck — Agent DAO Governance
Swiss rotating presidency as a model for AI agent DAO governance — continuous quadratic voting, futarchy overlays, and removing the human bottleneck from machine-to-machine decision making.
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.
Git Workflow Visual Guide: Organizing Local Code vs GitHub Repos
A visual walkthrough of a local Git workflow that separates your own GitHub projects from upstream forks and local experiments, with diagrams for every stage.
Self-Hosting DeepSeek V4 for Uncensored Local Inference
A practical guide to running DeepSeek V4 locally — model weights, hardware requirements, deployment options, and what you get vs the censored API.
DeepSeek V4 Is Censored — And Open-Weight Is the Escape Hatch
DeepSeek V4 is open-weight under MIT license but censored at the API level. Self-hosting eliminates the safety layer. The data privacy and silent refusal problems are real.
How I Curated an Awesome List of Projects Building on Original Bitcoin
The process, criteria, and research methodology behind original-bitcoin-awesome — a living directory of 2026-active projects on BSV.
Collapse Entropy to Zero — Dev Velocity and the Human Limit
Cognitive vertigo is what happens when the number of open decisions exceeds working memory. The fix is not more caffeine — it is collapsing entropy to zero by eliminating all unresolved state.
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.
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.
AGI vs. ASI — The Definitions Debate, and Why "G" Stands for Glue
Daniel Miessler published useful AGI/ASI definitions in June 2026. His role-vs-task distinction is the right framework — but it still assumes "General" means something it doesn't. The "G" stands for Glue.
AGI Is a Competing Worldview — Intelligence, Civilizational Narratives, and What a Neutral Perspective Sees
The previous post argued AGI is defined by power, not technology. This one goes further: AGI itself is a competing worldview — a vehicle for civilizational narratives about what intelligence is, who has it, and who gets to decide. A neutral perspective observes both the Western and Chinese poles from outside.
What Is a GitHub Fork? (And Why Mine Was Broken)
I tried to contribute a feature to Hermes Agent and discovered my repo wasn't actually a fork. Here's what I learned about how GitHub forks work -- and why "fork" on GitHub doesn't mean what I thought it meant.
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.
CachyOS Limine Default Kernel — Following Upstream
How CachyOS configures Limine bootloader entries for multiple kernels, and what the upstream default actually is.
The BSV Agent Coordination Layer: A Visual Architecture
Dumping Flatpak from CachyOS — 5.8GB Reclaimed
Removing Flatpak and its massive runtime bloat reclaimed nearly 6GB on my KDE CachyOS system
One Language. One Ledger. How Clojure + BSV Is All You Need for Sovereign AI Agents
A Developer's Guide to Agile & Scrum: Demystifying Assignment 1
An in-depth pedagogical breakdown of Agile principles and the Scrum framework, mapping out accountabilities, Sprint ceremonies, and empirical feedback loops using rich visual diagrams.
Tool Calling — How AI Models Learn to Act, Not Just Talk
A deep dive into tool calling — the mechanism that transforms a passive language model into an active agent capable of executing real-world actions.
Security Is Just a Mindset
Security isn't a tool you learn or a certification you earn. It's a way of thinking about systems — and it changes everything you build.
Profile Drift — When AI Knows Things You Didn't Say
How I Accidentally Hid My Entire GitHub — and What It Taught Me About Visibility, Forks, and Irreversible Decisions
A detailed post-mortem of the 24-hour window where all my public repos went private — the bad advice I followed, the irreversible GitHub mechanics I didn't understand, and the Mermaid diagrams that explain what actually happened.
How I Fixed a Broken AUR Install in 2 Commands
Using aur-audit to diagnose missing PGP keys blocking wkhtmltopdf-bin installation on Arch.
AGI = Artificial Glue Intelligence
The machine learns faster than you do. That's the point. You are the glue — the intent, the taste, the "whether." The AI is the "how." And the glue is what matters.
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.
Building an AI-Powered E-Commerce Store from Zero to One
An end-to-end walkthrough of SmartShop - a Django REST + React + Google Gemini storefront with personalised recommendations, semantic search, and an in-app shopping assistant. Architecture, models, auth, the recommendation cascade, smart search, Docker, and a clean public release.
Training Data Poisoning: The Invisible Cyber Threat Reshaping AI Security
Data poisoning shifts the attack surface from code exploitation to data supply chain corruption. A security engineer's breakdown of how adversaries weaponize training data, the real-world impact across critical sectors, and the defensive posture required to protect AI pipelines.
Google vs SpaceX: Infrastructure Economics Compared — A Platform Security Lens
A technical breakdown comparing Google's centralized hyperscale data centers against SpaceX's distributed LEO satellite mesh, analyzing infrastructure value, compute economics, and what this means for platform security and DevSecOps decision-making.
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.
CachyOS Mirror Timer: Why Your Updates Crawl and the 10-Second Fix
The default cachyos-rate-mirrors timer runs every 10 days. Stale mirrorlists mean slow or failed updates. A systemd drop-in drops it to 7 days — survives package updates, zero upstream impact.
Building a Local Mermaid Viewer With the LLM That Can't Draw
Yesterday I wrote about why LLMs repeatedly fail at Mermaid syntax. Today I used one to build a zero-dependency, offline-first Mermaid viewer — and it broke the diagram three times before getting it right.
The Mermaid Loop: Why LLMs Repeatedly Fail at Diagram Syntax
A technical post-mortem on why advanced LLMs repeatedly make the same Mermaid syntax errors, analyzing training priors, tokenization biases, and the lack of inline compiler feedback loops.
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.
Resilient PDF Generation: Intercepting Playwright Failures with Headless Chrome Fallbacks
How to build highly resilient document generation pipelines that automatically fall back to system-installed Chrome shells when network restrictions or low-priority threads throttle runtime dependency installations.
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.
Network Diagnostics: Fixing Chrome Connection Drops on CachyOS
A systematic walkthrough of diagnosing Chrome connection drops — from DNS verification to ping tests, traceroute, and firewall inspection — with a Mermaid diagnostic flowchart.
Local vs. Cloud Inference: Keeping Your Laptop Cool and Quiet Under Load
How to diagnose thermal profiles, understand the difference between local vs. cloud AI inference on hardware, and configure Linux power profiles to reduce laptop fan noise during heavy tasks.
The Developer's Guide to Line Length: Fluid Layouts vs. Typographic Measure
Why making your site wide shouldn't mean stretching your paragraphs. An analysis of optimal line length and fluid grid architecture.
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.
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.
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.
Collapsing Auth Entropy to Zero: Debugging GitHub Credential Conflicts on Linux
A visual walkthrough of debugging conflicting GitHub credentials — OAuth tokens, classic PATs, SSH keys, and rogue environment variables — and collapsing them into a single source of truth.
Least Privilege Devops: Userspace Rust Toolchain Bootstrapping on Fish Shell
Why installing developer toolchains like Rust inside userspace ($HOME) is structurally superior to system-wide installations, and how to bootstrap it cleanly using the Fish shell path architecture.
The Software Janitor: Why the Industry Needs Fewer Builders and More Cleaners
Why the tech industry's obsession with "building" is creating a crisis of bloatware, and why the "Software Janitor" is secretly the most high-value engineering role in 2026.
The Autonomous OS: Btrfs, Snapper, and the Safety Net for Agentic SysOps
How openSUSE's Btrfs and Snapper transactional updates provide the ultimate safety net for non-deterministic AI agents running system operations (SysOps).
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.
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.
Hardening the Arch/CachyOS Build Pipeline: Native AUR Auditing with Paru & Babashka
A visual reference guide to native PreBuild hooks. We configure paru to automatically run our Clojure-based aur-audit scanner before compiling community packages.
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.
Demystifying Arch Linux Packaging: PKGBUILDs, the AUR, and CachyOS
A deep dive into how packages are built, shared, and optimized on Arch Linux and CachyOS. Learn the differences between PKGBUILDs, the AUR, and custom repositories.
Cognitive G-Force: Collapsing Development Time with Agentic Compilers
A raw reflection on completing 8 multi-system tasks in 46 minutes, and the literal cognitive vertigo of developing at agentic speeds.
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.
The 15-Minute VAPT: Zero-Backend Security on Neon and GCP
Traditional enterprise security audits take months and cost thousands. Here is how we audited, patched, and redeployed a secure, PDPA-compliant serverless payment split engine in under 15 minutes.
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.