The technology my software might be inventing (an honest inventory)

I build a platform called The Human Brain App — 400+ screens, one builder, AI as the pair programmer. When you ship that way, you invent things out of necessity: not in a lab, but at 1 a.m., because the honest version of a feature didn't exist yet.

Some of those things might actually be new.

That's the honest version of this article's premise. I haven't run a patent search. I haven't read every paper. What I can promise: every technique below is real, running in production today, and I'll tell you exactly where I suspect prior art exists.

1. Basis-tagging: honesty as a data structure

Most software separates a claim from its evidence with… nothing. A number appears on a screen. You trust it.

In my labs, every generated claim carries a basis tag computed at runtime: MEASURED (a value you actually recorded), CITED (backed by a live-checked source), PROJECTED (a labeled estimate), or THEORY. The LLM cannot self-serve the tag — the app checks the basis and stamps it. When AI writes an investor slide, the badge is derived from the database row, not from what the AI says about the database row.

Prior art: provenance systems in databases and journalism tooling do this for professionals. A consumer product where the honesty label is a first-class field the AI can't fake — that's the part I think is rare.

2. Dialect memory: a translator that learns your idiom

My Code Bridge translates English into working code. It also keeps a per-user dialect: short pattern strings the translator accumulates across runs ("this user says 'whenever X' and means a guard clause"), stored server-side so it follows you across devices. The next translation consults the dialect before synthesizing.

Prior art: prompt personalization exists in chat products; style memory exists in research. A persistent, user-owned translation dialect that grows run over run is, at minimum, an uncommon packaging.

No-fibs note, printed on the page itself: the patterns are accumulated LLM suggestions, not verified knowledge.

3. A 2D game that is literally a slice of a 3D world

In Slice, a glowing plane cuts a 3D voxel city — and the 2D platformer you're playing is the cross-section of the city at that cut. Drag the plane and the level morphs live: platforms appear and vanish where the geometry allows, orbs reveal themselves where the cut exposes them. The level isn't designed. It's derived.

Prior art: cross-section views are standard in CAD and medical imaging. A playable, morphing cross-section as the entire game mechanic is the part I haven't seen — though I'd genuinely love to be pointed at a counterexample.

4. Software that exports itself

My CSV Compare tool has a button that exports the entire app as a single offline HTML file — comparison logic, UI, everything — that runs with no internet, forever. Not a "download your data" button. The software hands you a copy of itself and lets you leave.

Prior art: single-file programs are as old as computing; PWAs cache themselves. The deliberate design stance — a web tool engineered so it can walk away and never come back — is the thing I find hard to parallel.

5. A synthetic voice with a cache budget

"Honey" is the app's narrator. Her lines are dedup-cached server-side: the same sentence costs nothing on repeat plays, and the character sounds identical across hundreds of tools, forever. A tiny voice-continuity layer — treating a synthetic voice as a durable character asset with an economics model, so a narrator can appear everywhere for near-zero marginal cost.

Prior art: TTS caching is plain good engineering. The invented-feeling part is the economics: a character whose cost curve drops to zero as she becomes more consistent.

6. The render badge that tells on itself

When my in-browser renderer produces a 1080×1920 ad, the app inspects what the browser actually produced and prints it: "WebM — TikTok prefers MP4, try Chrome," or "voiceover could not be baked in (cross-origin audio) — the file is silent," plus a guaranteed one-command ffmpeg recipe with the exact downloaded assets. The renderer refuses to claim success it can't verify.

Prior art: ffmpeg pipelines, obviously. Self-diagnosing output badges are, again, an honesty primitive more than a technology.

The real invention

Individually, most of these are probably reinventions. Good ideas have many parents.

What I think might genuinely be new is the substrate underneath all six: an AI-built platform where verification is cheaper than assertion — where checking a claim, a render, or a citation costs one function call, so every claim, render, and citation gets checked. Nobody had to decide to be honest. The architecture makes fibbing more expensive than truth.

I don't know if that's inventing. I know it's the direction worth shipping.

— Steve