Everything Is Changing Now

Keep a few small tools nearby

g_o22@yahoo.com (Gideon Onyewuenyi) — Sun, 18 Oct 2026 00:00:00 GMT

Keep a few tools that do one thing well. A text editor you understand. A notebook that opens flat. A script whose entire behavior fits on one screen.

The point is not austerity. It is to spend less time negotiating with the tool and more time doing the work.

A place of your own on the internet

g_o22@yahoo.com (Gideon Onyewuenyi) — Mon, 12 Oct 2026 00:00:00 GMT

There is a meaningful difference between posting somewhere and publishing somewhere.

Posting is immediate. You put a thought into a stream, where it competes with everything written five minutes before and five minutes after. Publishing asks a slower question: is this worth giving an address?

An address changes the work. A page at a stable URL can be corrected, linked, rediscovered, and passed between people who were not present for its first appearance. It becomes a small piece of infrastructure.

The domain is the durable part

Software changes. Hosting companies disappear. A framework that feels inevitable today will eventually look like a very specific product of its decade. The domain and the files matter more than any of them.

That is why this site keeps posts as ordinary Markdown. If the current machinery becomes inconvenient, the writing can move without being rewritten. The public URLs can remain where they are.

Own the address, keep the source, and treat redirects as promises.

This is not an argument against publishing elsewhere. Syndication is useful. It is an argument for having an original: a place from which every copy descends and to which every copy can point.

Fewer measurements, better attention

When the page is yours, you can decide what not to measure. You do not need a dossier on each reader to learn whether the writing helped people. Aggregate counts, replies, and links are usually enough.

The resulting page can be almost embarrassingly plain. That is fine. The words are doing the work.

Building a writing system that can last

g_o22@yahoo.com (Gideon Onyewuenyi) — Mon, 28 Sep 2026 00:00:00 GMT

Building a writing system that can last

A writing system should make publishing easy today without making migration difficult ten years from now. Those goals sound compatible, but many tools achieve the first by quietly giving up the second.

The durable approach begins with a boring source format, a small number of explicit rules, and a build process that can be replaced.

A useful publishing system resembles a workbench more than a control room.

Start with the artifact

The primary artifact is the writing itself, not the page template and not the database row. Store it in a format that remains legible without the original application.

Markdown is not perfect, but its failure mode is unusually kind: when the rendering system disappears, the source still looks like writing. A post needs only a small header and a body.

title: Building a writing system that can last
date: 2026-09-28
type: long-form
tags: [writing, systems, web]

The schema should reject mistakes early. A malformed date or unknown content type is cheaper to discover during a build than after publishing.

Make URLs a promise

A durable URL is a commitment to readers and to other writers. Slugs should therefore be plain, memorable, and independent of categories that may change.

URL pattern	Durability	Problem
`/2026/09/a-title`	Medium	Dates become permanent structure
`/writing/a-title`	Medium	Categories change
`/a-title`	High	The title alone owns the address

If a slug must change, add a redirect. Broken links are not merely an SEO problem; they break the web’s memory.

Keep the build replaceable

The build system has three jobs:

Validate the source.
Turn it into accessible HTML.
produce indexes and feeds.

It should not become the only program capable of understanding the archive. A tiny content helper is enough to establish the important policy:

export function visible(posts: Post[]) {
  return posts
    .filter((post) => !post.data.draft)
    .sort((a, b) => b.data.date.valueOf() - a.data.date.valueOf());
}

Everything else is presentation.

Publish for more than browsers

Readers arrive through browsers, feed readers, email, search engines, command-line tools, and increasingly software agents. A durable site should serve all of them from the same source.

That means producing full-content RSS, a small JSON index, raw Markdown, and useful metadata. These are not separate editorial workflows. They are alternate views of the same files.[^one-source]

[^one-source]: One source also prevents quiet differences between the email version and the permanent web version.

The final test

Imagine opening the repository on an unfamiliar computer after five years. Could you find a piece of writing? Could you read it without installing anything? Could you move the archive to another generator in an afternoon?

If the answers are yes, the system is probably durable enough. Stop improving it and write.