beth.sh

Writings

  • Without anything actually being said.

    The last poem I wrote, 15 years ago, was this:

    There are too many words.

    Too many poems.

    Too many words

    In most poems.

    It’s called “Token-type”, because in the poem there are 14 tokens of words, but only 8 unique word types. I thought it was a pretty neat way to embody the distinction made in analytical philosophy between “tokens” (instances) and “types” (the general, uninstantiated kind of thing).

    It’s also an attempt at being maximally parsimonious with words — in-keeping with the theme.

    With the advent of AI, words are being usefully reduced to a different kind of “token”. A token of meaning. Miraculously, this allows LLMs to “speak” (process and create coherent bundles of words) in no single human language, but all of them at once, symbolically. This is indeed incredible.

    However, it’s also led to a great many more words. There were already more words than could ever be humanly read before LLMs. Now the number of words has exploded. Is exploding. But what is being said?

    In the before times, all words had been thought by another human. As the exponential output of LLMs continues, the ratio of human-thought written words will tend towards 0. Of course, all words – qua word types – have been thought at some point. But any instance (token) of an LLM-generated word has, by definition, not been thought by a human.

    Prompt: “@Create image about the type-token distinction in philosophy. Or better, an image that embodies the type-token distinction somehow.”
    I think we can all agree that ChatGPT decided on the lower-effort option.

    And who is reading all these words?

    Children now will grow up reading more words from LLMs than people-words. This is sure to change the collective brains of humanity.

    Then again — who is reading these enormous reams of words right now?

    Likely another AI, to be frank. “Summarise this document”. Probably one of the most common requests, if I were to hazard a guess. A plausible-sounding summary of a statistically plausible-sounding output to what was once a human prompt.

    Perhaps we will start requesting other people just give us their inputs, instead of the outputs?

    “Just give me the prompt, I’ll do the rest”

    Then we can run that ourselves, on our preferred model, with our CLAUDE.md preferences already built-in.

    Perhaps we’ll all start talking natively in caveman (“Respond terse like smart caveman. All technical substance stay. Only fluff die“). I mean, it has a certain appeal.

    When I re-read the poem I wrote 15 years ago, just before I hung up my writing pen, there is a palpable sense of something between despair, disillusionment, and defeatism. It is an ode to my own weariness with odes.

    I suppose that is what this short essay is, too. A moment’s reprieve — not just from AI slop, but from all AI-generated words. A quick “time out” where I try to remember what it is like to think in full sentences, not structured prompts. I read my writing now as I type and wonder — is even my own writing style being influenced? Did I always use the em-dash so much? Did I always use this rhetorical flourish of “this, not that”? If so, did I never think through how many false dichotomies I might be creating?

    Maybe it’s time to write more. Keep some semblance of an ability to think in my own human words. To hold on to a voice of my own.

    If only there weren’t so many damn words.

  • Zen and the Art of Code Maintenance

    There are 3 questions that I think it’s useful to actually ask to your code. Frankly, they’re useful to ask your self, too.

    I cover these in my React Alicante 2025 talk:

    Despite my nerves at the start, I’m glad I managed to make it clear how important it is to use types to prevent your code from leaking away valuable information.

    Types are a tool for describing your reality; the ontological space in which your code exists. This is usually domain-specific, but even if it’s pretty generic (the distinction between Admin and User, for example), it should be clear when these are two independent things in your digital reality.

    Do real things have optional properties?

    I basically always watch out for optional properties in types. Often a property is not truly optional — we just haven’t made clear the conditions under which it always holds true.

    For example:

    export type User_Not_Zen = {
name: string;
email: string;
age: number;
role?: "admin"; // optional - but is it really? 
};

    This type is not ontologically accurate if your admin users always have the property role: admin, and your other users never have that property.

    Compare the above type with the following more accurate (thus more Zen) types:

    type User = {
  name: string;
  email: string;
  age: number;
};

/** In reality, admin users always have a role. So this is the true type. */
type Admin = {
  name: string;
  email: string;
  age: number;
  role: "admin";
};

    When we go to add an if block with the condition (role === admin) then we (and our IDE) can actually see that we are deadling with one type of thing (admin user), and not another (user).

    For parsimony, we may wish to extend User to create the Admin type (below) — but only if they otherwise always covary:

    export type AdminUser = User & {
  role: "admin";
};

    If they always covary (i.e. when User changes, Admin also changes) then we know these are properly codependent. Interdependency is also information that can be expressed in the code, through proper use of type extension.

    So why is this more Zen? Zen speech is truthful. It expresses understanding, aids understanding, and therefore reduces suffering.