Andrew G. Stanton (Akamaister) Builder · Writer · Bitcoin-aligned systems
Founder & Fractional CTO. I build durable software and publishing systems rooted in conviction, sovereignty, and long-term thinking.
Following Jesus. Building with proof of work, not proof of hype. Still building.
Primary work MyContinuum — sovereign publishing & identity https://mycontinuum.xyz
Archive (RSS) https://nostr.mycontinuum.xyz/e/rss/npub19wvckp8z58lxs4djuz43pwujka6tthaq77yjd3axttsgppnj0ersgdguvd/kind/30023.xml
Nostr npub19wv…guvd
Verify Tool:
https://nostr.mycontinuum.xyz/e/verify.html
PGP fingerprint B480 CC98 7E0B AA6D 5962 EBAA BF2E 7F14 860D 3FB0 Full key: https://andrewgstanton.com/pgp
Last generated: 2026-05-24 12:21 PM PST
In Part 1, I described the architecture behind a decentralized publishing pipeline using Nostr, GitHub Actions, and GitHub Pages. In this follow-up, I walk through what it actually took to get that same pipeline working again in a new repository — including authentication issues, workflow permissions, and the small but critical details that make it all run automatically.
Last summer, I built a decentralized blog using Nostr, GitHub Actions, and GitHub Pages. I’m now taking that same idea and applying it directly to Continuum — turning tagged articles into a live, automatically updating site with zero manual publishing steps.
A reflection on how the recent build, packaging, and distribution work is helping Continuum better embody the principles laid out in *Building Continuum: Local Authority in a Networked World*.
Today I received the first sats purchase of *Building Continuum: Local Authority in a Networked World*. More than the amount, it felt like the first real signal that the work is reaching people in a way that aligns with its core message.
Today felt like a real threshold moment for Continuum. Cross-platform support across macOS, Windows, Docker, and local-host environments makes the ideas in *Building Continuum: Local Authority in a Networked World* far more tangible.
A reflection on why signing and notarizing the native Mac application was a critical milestone for Continuum. This piece explores friction, trust, user onboarding, and why local-first software must feel as smooth and trustworthy as cloud-native products.
A personal reflection on the past few weeks spent focused on native builds and release infrastructure, and why that did not represent a pause in creativity but a shift from writing into another form of authorship: building the vessel that carries the words.
Nostr clients are powerful — especially for discovery and interaction. But they are not designed for ownership, authoring, or long-term control. This article explores why clients are essential, but not sufficient, and what changes when you separate discovery from creation.
Most modern systems collapse writing and publishing into a single action. This creates hidden pressure and limits how ideas develop. This article explores why separating authoring from distribution matters — and how local-first systems restore a healthier way to think, write, and share.
Most modern tools assume constant connectivity. If the network is down, the system stops working. This article explores how that assumption quietly reshapes how we create, think, and work — and why local-first systems restore something deeper than just offline access.
Most people believe they “own” their accounts, data, and identity online. In reality, they have access — not ownership. This article explores how small, everyday failures (like password resets and lockouts) reveal a deeper architectural problem, and why local-first systems change that foundation.
Clarity is not discovered in abstraction. It is formed through the act of building—over time, through resistance, iteration, and commitment.
The absence of recognition is not a signal to stop. It is often the condition required to build something that lasts.
Building is not just creation—it is stewardship. It reflects how we manage time, responsibility, and what has been entrusted to us.
Sabbath is not a recovery mechanism for exhaustion—it is a return to alignment with God as the true source. This article explores how rest reframes work, exposes hidden dependencies, and reshapes the way we build, write, and live.
Sabbath reveals whether we are building in trust or in control. This article explores how our attachment to work exposes hidden dependencies, and why true durability requires the ability to step away.
Most systems tightly couple the act of creating content with the act of publishing it. This creates dependency on networks, platforms, and infrastructure at the moment of creation. Local-first systems must separate these concerns. This chapter defines the distinction between authoring and distribution and explains how decoupling them enables durability, flexibility, and true sovereignty.
Most systems treat identity as an afterthought — something layered on top of functionality through accounts and authentication. Local-first systems cannot. Identity must be foundational, shaping how data is created, signed, verified, and distributed. This chapter defines identity as a first-class primitive and outlines the design implications of building systems around it.
Local-first systems prioritize determinism — predictable, reproducible behavior — over dynamic, server-driven state. This chapter explains why determinism is essential for trust, recoverability, and durability, and how it shapes system design choices around state, execution, and synchronization.
Software-as-a-Service did not become dominant because it was inherently better for users. It became the default because it aligned with the economic incentives of companies and the operational realities of the web. This chapter explores the forces that led to SaaS dominance and why those forces continue to shape modern software architecture.