Verifying Human Authorship

When returning to a blog after a multi-year hiatus, a certain level of apology mea culpa is practically required.

I had actually committed to a New Year's resolution to increase my writing output. Following the collapse of my company last year, I found myself brimming with technical insights that I felt were both important to share and necessary for the world to hear.

• Review the spreadsheet of blog ideas
• Admit that I struggled to actually start writing

A cocktail of "I was too lazy," "I was too busy," or "I feared a lack of interest" kept me from the keyboard. However, this doesn't mean I've been silent; I recently published "How to Keep Well in Wartime" and continue to manage Inch Press, alongside a constant stream of side projects and open-source repository maintenance.

---

The AI Paradox

I recently encountered a piece by Mitchell Hashimoto that opened with a disclaimer that is becoming increasingly prevalent:

"this was completely hand-written with no AI assistance"

To be clear, I am not an "AI-hater." In fact, I integrate these tools into my professional life daily. My usage includes:

• Generating production-ready code.
• Running isolated experiments in my terminal.
• Managing open-source contributions (writing commits, providing peer feedback).
• Automating complex workflows that would be too tedious to script in bash or Ruby.

AI is a technology, and like any other, it is here to stay. It is far more productive to master the craft of collaborating with it than to waste energy resisting it.

The Joy of the Puzzle

One of my primary loves for programming is the thrill of solving technical riddles. AI enhances this by allowing me to specify a goal—"do X using Y because of Z"—and then step away to pet my cat or brew a third cup of coffee while the machine handles the "tip-tapping."

However, I worry about the "smoothing of my brain." There is a deep irony here: the only reason I can effectively prompt the "beast made of rocks" is that I spent two decades accumulating the "infernal knowledge" required to communicate with it. While I am happy to delegate the physical act of typing code, I still crave the mental friction of the problem-solving process.

Coding vs. Writing

There is a fundamental difference between using AI for logic and using it for language:

1. Deterministic Goals: In coding, the objective is often binary. The button must function; the layout must align.
2. Process-Oriented Goals: In writing, the way you reach the conclusion is the point.

AI is an expert in "content optimization"—it knows how to use staccato rhythms or dichotomous framing to manipulate reader emotion. But because the journey of drafting is where the thinking happens, I prefer to use my own hands for my thoughts.

---

The Solution: How to Prove Humanity?

This leads to the central question: How can we verify that a human actually wrote a piece of text?

The premise is simple: the difference between a human and an LLM is time and effort. A human is slow; a human leaves digital fingerprints in the form of keystrokes.

Introducing Semoi

Semoi is an Obsidian plugin designed to track the provenance of a document. It monitors:

• The total duration of the writing process.
• The specific number of keystrokes utilized.

The Workflow

Once the piece is finished, the data is sent to a server that cryptographically signs and mints the record to prevent tampering. You can then embed a badge on your site to prove your authorship.

The Logic of Detection

If we analyze a 1,000-word post, the mathematical difference is stark:

$T_{human} \approx \text{minutes/hours} \gg T_{AI} \approx \text{seconds}$

Furthermore, the event stream differs:

• Human: Thousands of keydown and keyup events.
• AI: A single paste event from a terminal into an editor.

Technical Implementation

The server doesn't see your text (preserving privacy); it only receives a JSON blob of metadata:

{
  "document_id": "blog_post_01",
  "total_keystrokes": 5420,
  "duration_seconds": 7200,
  "events": [
    {"timestamp": 1721700000, "event": "keydown", "key": "H"},
    {"timestamp": 1721700001, "event": "keydown", "key": "e"}
  ]
}

Limitations and Ethics

Of course, the system isn't foolproof. A user could type gibberish for an hour, then paste AI text over it. However, the system ensures that no personal identity or content is leaked—only the timestamps and event counts.

I previously detailed this system in a presentation at WordHack.

Final Thoughts

My GitHub profile is a garden—some plants are thriving, while others have long since withered. But my hope is that by sharing this, I might inspire someone to develop an even more robust method of verification.

As Lucia Joyce once declared:

"C’est moi qui est l’artiste"