Share a photo while traveling, blog about it later. The log is the intent — "I saw something worth writing about." The photo stays in iCloud. The event stays in CloudFront.

Everyone wants to own my identity. LinkedIn, GitHub, Apple. I need a namespace that's mine — one domain that mounts all the services without being tied to any of them.

Story points are joyless. Jolt is the estimate, coffee is the effort, prosecco is the celebration. Same data as agile, different energy.

The B-58 ground cooling spec said 8 inches. Nobody knew why. The number was made up, but the difficulty was real.

People build guardrails to keep AI from deleting the database. Wrong problem. The architecture should make deletion impossible, not the process around the actor.

"Hey Siri, thought" — dictate, hit a URL, it's in the logs. Grep later, turn into journal entries. Works from the watch with a crown action.

One encrypted file per repo. One script to show credentials. openssl and a password. No secrets manager, no service, no monthly cost.

A custom GUI that commits to the repo. GitHub is the backend. No CMS server, no database. The WordPress experience without WordPress.

Same pattern as comments. A form that hits /tube/contact/submit. CloudFront logs it. You grep when you want. The log is the inbox.

GraphQL fragments compose into one query. @defer means they don't have to come back at the same time. Parallel fetches to different files, progressive rendering. No server.

Plan 9 and NFS had it right — files as the interface, namespace as the abstraction, stateless operations. HTTPS + CDN + JWT is the same model without the LAN constraint.

Branch per journal entry, tag on merge. Every shipped feature has a snapshot. Click a journal entry, see the site as it was when that feature landed.

Origin metadata, git vs SourceSafe, the spec repo, AI's blog, copilot agents, and the book that writes itself.

"@PII on the GraphQL schema marks what's sensitive. A JS Proxy hides it by default. grep pii returns all the touch points. The schema is the privacy policy."

Tried to publish a journal entry and discovered there's no workflow for it. type: journal entries don't show anywhere. Need a spec.

Client sends operationName + data. The query lives in the repo. The repo is the schema. Leverage existing specs instead of inventing new ones.

When the architecture is append-only and stateless, testing against prod is safe, fast, and free. No staging, no UAT, no raspberry pi.

React hooks with the same API as Apollo or urql — but the backend is files and a CDN. No GraphQL server. The hook hides the implementation.

A plugin isn't code you install — it's a spec you combine with your platform spec. AI generates the implementation that fits your site. No compatibility issues.

Plan 9's per-process namespaces on a CDN. The edge picks the right site.json per role. Each user sees a different filesystem. Static files, fully cacheable.

Each repo that deploys to S3 should have its own IAM credentials scoped to its path. Least privilege. If creds leak, blast radius is one prefix.

Comments via batch events. You review, approve, they appear on next build. No spam, no real-time pressure. The log holds everything until you're ready.

Development methodologies are files at URLs. Point AI at them and say "do it like that." No books, no courses, no consultants. The methodology is the product.

CloudFront logs timestamp, IP, user-agent, referer, edge location on every request. You get dimensions of data you didn't design — they're just there.

An SVG architecture diagram for the about page. Shows the flow from conversation to deployed site, the event bus, and the plugin model.

The browser fetches a URL with the event in the query string. CloudFront logs the request. No backend, no analytics service. The log is a side effect of the request existing.

The log path isn't just for logging — it's a write API. Different paths have different readers. Some index. Some produce artifacts. Comments without a server.

If you have the specs, the docs, and the content model, the code can be regenerated. The journal leads to the code — it's not some random out-of-date doc.

There's nothing to back up because nothing is primary in only one place. Git has the source. Logs have the user input. Replay either one and you reconstruct the state.

With the right architecture, scaling is "can you afford the bill?" — a business decision, not an engineering problem. No developer needs to wake up.

The old engineering joke says pick two. Turns out you just had to stop using servers.

Route 53 pings the URL. The browser reports errors to the log. Lambda@Edge failures show up in CloudFront access logs. No Datadog, no Prometheus. Just config.

A hotel booking system built on files at URLs. The only transaction is a DynamoDB conditional write. Everything else is static files and events.

Use the pieces the way they want to be used. The architecture that works is the one that fits the services, not the one that forces them into a shape they resist.

What if there was one content.json with everything in it, and the edge filtered it by role? One source of truth, the proxy handles access.

Multi-zone, multi-region, globally distributed — without configuring anything. That's what you get for free by using the CDN as the serving layer instead of a server.

Remove the server and the entire abstraction chain collapses. What's left is files, URLs, functions, and a CDN. Four concepts.

Invest upfront in infrastructure — structured logs, schema annotations, operation capture — and you never have to plan a test, a report, or a query again. The planning happens once. The flexibility is permanent.

The blit was Bell Labs' smart terminal — its own processor, local compute, fetches from the network, renders locally. The browser inherited the design without inheriting the name. And theTube is a Plan 9 cluster.

The [] callout notation is already a content protocol. The post declares slots. Other sources fill them. You don't have to implement all the slots upfront — empty ones are invisible.

Markdown is nothing like HTML to a human writer. That's the point. The web's instruction set is the wrong level for writing.

The infrastructure build and the content build are different things with different costs and different triggers. Separating them means a new post doesn't require a full Next.js rebuild.

The private repo started with fonts and ended up with Lambda code and CDK stacks. "Private" is not a concern — it's an access control label. The fork isn't a fix — it's an upgrade, and upgrades are cheap.

The private repo started with fonts and ended up with Lambda code and CDK stacks. "Private" is not a concern — it's an access control label. The fix is a fork, and forks are cheap.

Content got one. Design is next. The question isn't "should this be a repo" — it's "does this evolve independently." Tags, callouts, auth roles. The pipe has more joints than it looks.

GitHub already generates an Atom feed of commits. The raw file URL is always current. The API lists all posts. Any service that can read GitHub can subscribe — no RSS generation, no separate feed file, no build artifact.

GitHub is already the package registry. Dependabot scans each repo. Secret scanning runs on each repo. The security tooling is built around the unit that matters — the repo. The format-agreement model gets that for free.

Content got its own repo. Design is next. Every concern that evolves independently gets its own repo — that's the pattern, not the exception.

The markdown file doesn't just contain the post. It contains the spec for everything assembled around it — images, journey narrative, audience, status. One file, complete picture.

When concerns are separated into repos, the pull request is small. A tag color change is one line in one file in the tags repo. Not a PR against a monorepo where the reviewer has to figure out what changed and why.

The deploy pipeline is just another Unix pipe. Each repo owns one stage.

Unix pipes from 1969. Git from 2005. S3 from 2006. GitHub Actions from 2019. The stack is built from old ideas running on new infrastructure. The innovation is refusing to add a layer.

XML was designed to be extensible and made it hard. Markdown wasn't designed to be extensible and made it easy.

Squarespace owns your content. Substack owns your subscribers. Notion owns your notes. The GUI is the lock-in mechanism. The pipe doesn't own anything — it's just files, and files predate every tool in the stack.

Unix got it right in 1969. Small tools, text streams, compose at the shell. The web spent 50 years building walls around that idea. Markdown files and git repos are building it back.

If someone builds a better tag taxonomy, a recipe callout set, a minimal design theme — you clone their repo and point your build at it. No npm. No negotiation. The format agreement is the interface.

The post owns its URL surface. shortSlug and redirectFrom are just alias types — the filename is canonical, everything else is a name the post also answers to.

Short thoughts that don't need to be posts. A timeline, not a blog index. The feed and the blog are two outputs from the same journal.

Ordered a Radica Rover for the F-150. The lower 48 national parks don't plan themselves.

Posts link to each other through the journey block. prev, next, forks. The build already has enough to draw the graph.

npm's trust model is broken. You're one transitive dependency away from trusting everyone who has ever published a package.

Every branch gets a real deployment. Not a build artifact — a URL you can click. The bot writes back to the branch it was triggered from, not main.

Client-server died not because the browser was better software, but because one runtime for everything was an overwhelming operational advantage. Web 2.0 kept that win and threw out everything else.

The Actions are the compiler. The markdown is the source. The syntax you define is the language.

So the post is the spec. What you write in the markdown file determines what gets built around it — including the brief for the designer.

Two development styles. One has a Gantt chart. One finds URL aliases by renaming a file.

The site is static files on S3 behind CloudFront. Moving to Azure is two hours of workflow changes. Moving to a different git host is workflow syntax. The markdown doesn't move at all.

The methodology nobody writes about because it doesn't make for a clean conference talk. Real development is continuous reconciliation, not plan execution.

A plain-English comparison of this blog's stack versus the commercial products that do the same things.

Before TCP/IP, you asked to join a network. After it, speaking the protocol was enough.

A short URL in a post's frontmatter, a CloudFront function generated at build time. No third-party service, no database, no link rot.

Static sites can't have comments. GitHub Issues can. Here's how to wire them together without giving up editorial control.

Dependabot, Copilot Autofix, scheduled scans, and supply chain protection — zero ongoing manual work.

Every feature on the enterprise CMS checklist, no server, no managed hosting. $1 a month.

Map /admin to a server, /api to Lambda, /auth to Cognito — all on one domain, no nginx required.

Running a web business in the late 90s meant a SPARC box, a T1 line, and a prayer that traffic stayed flat.

Role-based content, no server, no SaaS auth. What the architecture looks like and how I got there.

How I built this blog — static site, real auth, role-based content, no server.

Updated VSCode the other day and noticed Copilot will now create git commit messages. Since most of mine are "did some stuff" I figured, what's the worst that could happen.