Read the Hard Books

I'm guessing that many people who own Spinoza's Ethics have read maybe four pages of it.

The Ethics opens with eight definitions and seven axioms before it makes a single claim, and one of those definitions is for the word substance. If you read "substance" and think matter, material, the stuff a thing is made of, which is what the word means everywhere else and what a dictionary will tell you, then you have just misread the foundational core of the entire book. Everything after it rests on a word you have backwards. Four pages later the sentences stop making sense, and the natural conclusion is that the book is above you.

It probably isn't. You might just not be understanding the terms.

That gap (between wanting to read philosophy and being able to) is the focus of a tool I've been building lately. It's called Be-ing, and the whole product fits in one sentence: it puts the definition where your eye already is.

The wall is vocabulary, not difficulty

Difficult philosophy is not hard because the sentences are long. Some of them are, but that's a translation problem and a stamina problem which can be solved with focus and pushing forward. What makes most philosophy difficult is a handful of ordinary words have been bent to technical purposes, and the author assumes you already know it.

Substance, mode, attribute, contingency, intuition, a priori, Dasein. Each one carries a specific, engineered meaning. Each one shifts between authors, and sometimes between chapters of the same author. Reach for a dictionary and you get the ordinary meaning, which is precisely the one the philosopher set aside on purpose. Miss a dozen of those and the argument dissolves. Not because the thinking is beyond you, but because you have swapped in the wrong meanings and kept reading.

Readers have always known this, and they have always built tools for it. Companion volumes. Lexicons. Study guides. Margins crowded with pencil. Medieval scribes glossed manuscripts between the lines, which is where we got the word gloss in the first place. The practice is ancient and it works.

The trouble is that it has always lived outside the page. A glossary at the back means flipping. A translator's footnote means a different page. Wikipedia means a different century's argument, in a different tab, with a link to Kant that you will click. Every one of them costs you the thread, and with this kind of book the thread is the whole thing. You are following one long argument through a lot of sentences, and if you set it down to go look something up, you set down the argument too.

Two definitions, and only one of them is interesting

So every technical term in Be-ing gets a gloss, and the gloss appears alongside the text rather than over it. That's the boring half.

The interesting half is that every term carries two definitions:

• a general definition: what the term means across philosophy, shared by every book in the library
• an in-context definition: what this author means by it, in this sentence, on this page

The second one is important. The same word gets explained differently every time it appears, because it is doing something different every time. Here is Plato, in the Theaetetus, on wonder:

Wonder here is not idle curiosity but thaumazein — astonishment at what is ordinarily passed over, which Plato identifies as the starting point of all genuine inquiry.

And a few lines later, on the mythological pun Socrates makes:

Iris, the messenger, is born of Thaumas, wonder — so philosophy descends from astonishment rather than from certainty.

This is similar to what a good teacher says about the word in context.

Terms are also glossed on every occurrence, not just the first, which is deliberate and a little expensive. A reader should never have to remember a definition from eleven pages ago, or scroll backward to find where a word was introduced. But there's a better reason than convenience. Encountering the same word explained six different ways, in six different sentences, is how you actually learn a word. It's how you learned words as a child (repeated exposure in varying contexts) rather than how you learned them for a standardized test. In one chapter of one book, "ontological" showed up six times: ontological surprise, ontological mystery, ontological pedigrees, ontological fortuity, ontological poverty, ontological indigence. Same general definition each time. Six completely different explanations of what it's doing in that sentence. By the sixth, you own the word.

Two rules govern how the glosses get written, and both sit in the prompt verbatim.

An eighth grader should understand it; a college philosophy student should respect it. Those constraints pull against each other, and that tension is the point. Most explanatory writing fails by picking one.

The gloss doesn't take the author's side. The general definition stays neutral across philosophy. It doesn't adopt Spinoza's account of substance just because you happen to be reading Spinoza. Spinoza gets to argue for his definition; the apparatus doesn't get to argue for him. Getting this wrong would turn a reading tool into a very subtle kind of propaganda, and it would be nearly invisible.

Why nobody built this before

Because somebody has to write the glosses.

Not one per term. One per occurrence. The library currently holds thirty-six books and just over seventeen thousand general definitions, and the occurrence count, each with its own contextual explanation, is several times larger. As an editorial project that's a career, not a book, which is why this apparatus exists for a handful of famous texts in scholarly editions that cost eighty dollars, and for nothing else.

That's the part that changed. This is a good use for a language model, and I want to be precise about why. Not because it's smarter than a scholar (it isn't), but because it will do the same careful, unglamorous thing seventeen thousand times without getting bored or quitting. And the work compounds. Once a book is glossed, it's glossed for every reader who comes after, at no additional cost.

Is it as good as a great human editor? No. But it beats what it's really competing with, which is nothing at all.

What it feels like to read

The design language is lifted from critical editions, because that's the tradition this belongs to. Paper-colored grounds. One disciplined rubric red, used for glossed terms and section marks and never as a button fill. Asterisms for section breaks. Dotted leaders in the table of contents. Literata for the text, and a mono face for the apparatus voice: labels, numerals, metadata. Typography does the talking and nothing glows.

Books are split into sections rather than pages, 150 to 300 words each, proposed during import. Short enough to hold in your head, long enough to be an argument. Glossed terms carry a red underline; open one and the definition appears beside the text, so you never lose your place.

And then there's the video.

Behind the text, ambient video crossfades as you scroll. Sixty visual styles across twelve categories (metaphysics/the-ground-of-being, eastern/impermanence-anicca, time/eternal-recurrence, existentialism/thrownness) with a hundred and thirty-eight clips behind them. A section points at a style, never a specific file, and a variety algorithm rotates through that style's clips so a long chapter doesn't visibly loop.

This is, by a wide margin, the least defensible feature in the product, and it's my favorite. It's also the oldest. The first prototype was a two-pane reader built around a single chapter of David Bentley Hart's The Experience of God, where scroll-driven video was more or less the entire idea. That book is in copyright, so it never went into the public library, but the reading experience survived the rewrite and the video came along with it. Some readers will turn it off, and that's fine. It's there for the ones who won't.

Making a book

The library is public-domain philosophy (Spinoza, Kant, Plato, Nietzsche, the Stoics, the Upanishads, Aquinas, Zhuangzi) imported and glossed by a four-stage pipeline that runs from the command line:

pnpm import-book           # Gutenberg → strip boilerplate → split into chapters
pnpm process-chapter       # sections, terms, in-context definitions, links
pnpm generate-definitions  # fill in the shared general definitions
pnpm review-book           # quality report before publishing

Nearly all the cost lives in stage two, and getting stage two wrong is expensive in a way that compounds across a whole library. Mine was wrong for a while.

The 35× fix

The original design made one AI call per occurrence of every term, with every call resuming a shared session so the model kept the chapter in mind. Resuming a session sounds thrifty and is the opposite. It works something like forwarding an entire email thread to ask one new question: by the twelfth call you're sending ten thousand tokens of replayed history to get back an eighty-token answer.

It was also doing something worse. It asked the model to re-emit the entire section text, verbatim, with [term](#anchor) markup inserted. Those are the most expensive output tokens there are. It can alter the author's words without anyone noticing, which for this project is close to the worst thing that could happen. And the JSON wrapper around it failed often enough that roughly a third of windows shipped with no links at all, silently.

Two changes fixed it.

Let code insert the links. The model already reports each term, where it occurs, and its anchor. Inserting the markup is a deterministic find-and-replace, so it became one: a pure function with Unicode-aware whole-word matching, compound phrases beating their parts (ontological poverty wins over a bare ontological), original casing preserved. Sixteen unit tests. Zero tokens, byte-identical text, and the parse-failure bug is gone by construction rather than by retry.

Identify and define in one batched call. A single prompt returns terms and their in-context definitions for a batch of four sections. No session resume, no padding.

Measured A/B on the same chapter, same model, pipeline as the only variable:

I suspect a lot of people are currently paying for the version of this I was paying for, so: don't hire a language model to do a find-and-replace. What you're buying is judgment, which terms matter and what they mean here. Judgment is a small fraction of the tokens in most pipelines. Everything downstream of it is bookkeeping, and bookkeeping belongs in code, where it's free, exact, and testable.

Problems along the way

The Red Lady

There is a 1920 Gothic mystery novel in my philosophy database.

The Red Lady, by Katharine Newlin Burt. It's about a woman in an isolated pine-forest estate who becomes convinced the house is haunted. It got in because I fat-fingered a Project Gutenberg ID, and then the metadata step did exactly what I built it to do. It was asked which philosophical tradition this work belongs to, so it answered the question it was asked, at length, with a completely straight face. Per the description now sitting in my database, the book "engages themes of perception, personal identity, and the limits of rational knowledge," and occupies "a modest but genuine place in the aesthetics of the sublime and the phenomenology of dread."

It was tagged Modern, Continental, and filed under Consciousness Studies.

The example is funny but the lesson is real: a model will answer the question you asked it. If you never give it a way to say "this isn't what you think it is," it will invent a plausible answer rather than reject the premise, and the answer will be well-written, which is the part that makes it dangerous. The import pipeline now has a rejection path.

The Red Lady is still sitting in draft status, having never been published, which is the one part of that story that worked exactly as designed. I'm leaving her there.

The bug that batching created

Batching the definition calls introduced a real reader-facing bug, and it's the shape of bug that batching tends to produce, so it's worth walking through.

Anchors are numbered per term: def-substance, def-substance-2, and so on. When each batch numbered its own anchors independently, two occurrences in different batches could both come out as def-substance-2. The reader keys its chapter-wide content map by anchor, so one gloss silently shadowed the other. You click a word and get the explanation for a different sentence.

Nothing errored. No test failed. The numbers just stopped being unique. The fix was a single counter shared across all batches, plus a pass that drops any occurrence whose anchor never made it into the text. Both are pure functions with tests, because that's the only way I'd trust them again.

Vibes are not a methodology

For a while I was changing prompts and believing they were getting better. I had no evidence that they were.

So the project grew a benchmark suite: fixed inputs, run across Claude, Codex, and OpenRouter, capturing exact tokens, turns, latency, and cost, with the submitted prompt and the raw reply side by side and a 1–5 grade on each. The whole pipeline runs behind a provider abstraction, so switching models is a flag.

One design note I had to learn twice: the leaderboards are scoped to a single fixture. There was a global cross-fixture leaderboard for about a day, until I noticed that averaging a model's performance across inputs of wildly different sizes produces a number that means nothing at all. A model can be excellent at short definitions and mediocre at splitting long chapters, and blending those two into one score tells you nothing about either.

The marathon

Processing the first twenty books took about six days of real time, spread across usage windows, producing roughly 750 chapters and tripling the definition count. It runs on a subscription rather than a metered API, which sounds like a footnote and turned out to be the most influential design constraint in the whole project. Every architectural decision in that pipeline (the batching, the code-side link insertion, the benchmarking) traces back to the fact that tokens are scarce here. I've come to think that's a feature. A budget makes you find the cheap version, and the cheap version turned out to be the correct version: fewer moving parts, deterministic wherever it can be, and never asking a model to retype an author's sentence.

Why I'm building it

The name comes from the translators.

When Heidegger wrote Seyn (being, spelled strangely on purpose) his English translators reached for a hyphen: be-ing. A word made deliberately unfamiliar so you would stop and look at it again instead of sliding past it. That's the whole method of this project, and most of the hope behind it. Slow the word down until you can finally see it.

Because the usual conclusion is wrong. Plenty of people own the Ethics; far fewer have read past the opening pages, and the story we tell about that is that these books belong to someone else. Someone trained. Someone with a seminar and a professor and four years. But they were not written for specialists. Spinoza wasn't writing for a philosophy department; there wasn't one to write for. What keeps people out was never the ideas. It's the apparatus: the companion volume, the lexicon, the seminar, the professor who tells you what "substance" means so you can keep reading.

The apparatus is the part that just got cheap.

Where it stands right now: thirty-six books imported, most of them published and readable, glossed end to end. The reading experience works. Uploading books you already own is built but not finished, and there's no billing, because I'd rather not take money for something I'm still fixing. The benchmark numbers need another pass. The Red Lady needs deleting, eventually.

But the measure of the thing was never the definition count. Spinoza opens the Ethics with eight definitions and seven axioms before he says anything at all, and that page is where nearly everyone quits.

That page is the whole project.