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 /w/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.

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.

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.

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.

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.

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 short URL in a post's frontmatter, a CloudFront function generated at build time. No third-party service, no database, no link rot.

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.