The guide is 12,000 words long. It has a table of contents. There are affiliate links, and you need to subscribe on medium to see the bottom third…

By the time you finish reading it, the framework has released a major version and the guide is already wrong.

It doesn’t need to be like this. There is a different way to build things on the internet. It has been available the entire time. You write HTML. You write CSS. You put the files somewhere they can be served.

This is not nostalgic. Fewer moving parts means fewer things that break. You spend more time writing and less time debugging your bullshit.

The stack is a solution to a problem most of us don’t have.

This site is built with a Python script and pandoc. The Python script is about two hundred lines. It has no dependencies outside the standard library. It calls pandoc to convert markdown to HTML and assembles pages from flat template files. I can do this from any computer that has an internet connection.

The pandoc binary is large for a single executable. It does one thing. It does it correctly. It has a command-line interface. It will probably do the same thing it does now ten years from now.

The HTML output is readable by any browser built in the last 30 years. The CSS is a flat file with no preprocessor. Time is a flat circle with an continuous preprocessor.

Nothing here requires Node.js. You could read this with wget.

The case for the stack is that it scales. True enough. It also requires three engineers to maintain the build configuration and a fourth to update the dependencies when a zero-day drops in a package four levels deep in the tree that nobody has heard of.

Most things don’t need to scale. They need to work, keep working, and be readable by the person who wrote them when that person comes back two years later.

This site’s entire build system:

    # TODO: insert this when you get the repos worked out

Two hundred lines total. No lock file. No node_modules. No CI pipeline to maintain.

This is not a popular opinion. Making things easier is supposed to be good. Accessibility is good. Lowering barriers is good. More voices is good. All of that is true and the internet is still worse, and I may be old but I swear I am not yelling at clouds here.

The early internet had friction everywhere. You needed to know what a DNS record was. You needed a shell account or a dialup connection and a local ISP that someone had to physically maintain. You needed to learn a text editor before you could participate in anything. The friction was not intentional design. It was just the state of things.

But the friction had an effect. It filtered for a certain kind of person. Not smarter, not better; just someone who wanted to be there enough to figure out the tools. That changes what kind of participation happens.

I often recall in the 2010-2015 years (interesting political overlap there) that people often spoke of a “marketplace of ideas”. I genuinely wanted to believe in that. Sometime around 2020 I recall seeing the apt and modern retort: “an Amazon of Concurrency”. I think that better captures the atmosphere we are left with.

Cory Doctorow calls it (or something very adjacent to this) enshittification. Platforms are good for users, then good for advertisers, then good only for the platform. Once a platform reaches scale, its users are the product. Their attention is the inventory. The platform’s job is to maximize the value extracted from that inventory.

Friction interferes with extraction. Some users leave before they can be monetized. Some conversations stay small and weird instead of becoming content.

So the friction gets removed. And the thing that made the place worth being in disappears with it.

The dark forest theory (under abuse) says that when public spaces become hostile, interesting people retreat to smaller private ones. Group chats. Email lists. Invite-only forums. Places where the entry cost is knowing someone who is already there.

The cost of entry is not money. It is social. You have to be the kind of person that other people want to invite. This is a form of friction.

The interesting internet didn’t disappear. It moved to places that require a little more effort to find.

This site has no comment section. There is no reply button, no reaction, no share count. There is nothing to optimize against. The only metric I have is whether I think the thing I wrote is worth reading.

We will see if that turns out to be a better hedge against metrics than I expected.

Python

#!/usr/bin/env python3
from pathlib import Path
from datetime import datetime, timezone


def parse_frontmatter(text: str) -> tuple[dict, str]:
    if not text.startswith("---\n"):
        return {}, text
    try:
        end = text.index("\n---\n", 4)
    except ValueError:
        return {}, text
    meta = {}
    for line in text[4:end].splitlines():
        if ":" in line:
            k, _, v = line.partition(":")
            meta[k.strip()] = v.strip()
    return meta, text[end + 5:]


if __name__ == "__main__":
    for path in sorted(Path("content/posts").glob("*.md"), reverse=True):
        meta, _ = parse_frontmatter(path.read_text())
        print(f"{meta.get('date', '?')}  {meta.get('title', path.stem)}")

Bash

#!/usr/bin/env bash
set -euo pipefail

SITE="lotek.run"
OUT="output"

if [ ! -d "$OUT" ]; then
    echo "run build.py first" >&2
    exit 1
fi

# rsync to remote, delete files that no longer exist locally
rsync -avz --delete "$OUT/" "user@$SITE:/var/www/html/"
echo "deployed."

Rust

use std::fs;
use std::path::Path;

fn slugify(title: &str) -> String {
    title
        .to_lowercase()
        .chars()
        .map(|c| if c.is_alphanumeric() { c } else { '-' })
        .collect::<String>()
        .trim_matches('-')
        .to_string()
}

fn main() {
    let posts = Path::new("content/posts");
    for entry in fs::read_dir(posts).expect("no posts dir") {
        let path = entry.unwrap().path();
        if path.extension().map_or(false, |e| e == "md") {
            println!("{}", path.display());
        }
    }
}

TOML

[site]
title = "lotek.run"
url   = "https://lotek.run"
desc  = "dispatches from the margins"

[build]
posts_dir    = "content/posts"
output_dir   = "output"
date_format  = "%Y-%m-%d"

[author]
name    = "unknown"
contact = "find a way"

SQL

-- hypothetical: if this site ever needed a database (it doesn't)
SELECT
    slug,
    title,
    date,
    array_length(string_to_array(tags, ','), 1) AS tag_count
FROM posts
WHERE date >= current_date - interval '90 days'
ORDER BY date DESC;

To add an image to a post:

1. Compress it. Phone photos are 4MB. That is not a web image.
2. Drop it in static/img/.
3. Reference it in markdown as ![alt text](/static/img/filename.jpg).
4. Run python3 build.py.

For compression: cwebp -q 80 input.jpg -o output.webp or jpegoptim --max=85 photo.jpg. Under 200kb for most images, under 500kb for anything you genuinely need at full resolution. Do not need things at full resolution.

Write actual alt text.

#TODO: implement auto image compression.  another build step _might_ be okay.

The name is from William Gibson’s Johnny Mnemonic. The Lo-Tek are an underground community living in the infrastructure of the city – on bridges, in access tunnels, in the margins between the corporate system and nowhere. Not against technology. They use what they need and not more.

That seems like the right disposition in 2026.

No schedule. Posts when something seems worth writing down. Long or short depending on what it needs.

If you want to say something about something here, find a way to reach out. The friction is intentional.