Most software is happy to preach its worldview from a safe distance. Much less software volunteers to live inside it. LLL does. `LLLTS` is written in its own language, which means the language is not merely a manifesto about how AI should build serious systems. It is also a daily test of whether those rules can survive contact with a real compiler, a real toolchain, and the slow grind of improving the product from inside its own discipline.
Before Software, The Hand Knew The Trick
Long before anybody said dogfooding, people were already trapped inside the same
loop. The blacksmith used a hammer to shape the next hammer. The potter fired vessels that
carried the water needed to mix the next batch of clay. The mason stood on stone he had shaped
to shape more stone. Human craft keeps doing this because reality is rude. If a tool is bad, the
maker feels the insult immediately.
That is the old contract. Make the thing. Then live with the thing. Not for a photograph, not for a launch page, but for the numb daily repetition where defects stop being theory and start becoming blisters.
The Loop Escaped The Workshop
This pattern did not stay in metal and clay. Printers built parts for printing presses with presses already running. Instrument makers used their own measuring devices to improve the next generation of instruments. Farmers saved seed from one harvest to grow the next. Tailors wore the same quality they asked customers to trust. Civilization loves the loop because the loop is a lie detector.
The interesting cases are not the glamorous ones. They are the ordinary ones. The trade refines itself by using itself. The workshop tests its worldview under boredom, deadlines, weather, and human error. That is where sincerity gets separated from branding.
Then Software Learned The Same Humiliation
Software arrived thinking it was special. For a while it looked special too. The early machine world was hand-fed: switches, raw opcodes, assembly. Then the abstraction stack started climbing. Assemblers helped replace direct machine entry. Compilers were first built in lower-level systems and, once they could stand upright, teams tried the real test: write the compiler in the language it compiles. Self-hosting stopped being a parlor trick and became a proof of adulthood.
That matters because a self-hosted language loses the right to be precious. Every clumsy rule punishes its own builders. Every hidden ambiguity comes home for dinner. The compiler team has to eat the friction, not just explain it in a polished document.
Dogfooding Got A Corporate Name, But The Meaning Stayed Brutal
Modern software gave the old idea a cleaner slogan. Eat your own dog food. Use your own database for real workloads. Run your planning tool inside your own planning tool. Design the next release inside the design tool you sell. The phrase is cute. The mechanism is not. It is a pressure chamber. It forces all the charming little excuses to report for duty.
This is why dogfooding still matters outside software too. A chef cooking on the same stove line the kitchen staff uses. A bicycle builder commuting on bikes from the same workshop. A medical device company instrumenting its own labs with its own sensors. The form changes. The test does not. Use the thing in a life that can punish you.
Why This Matters For LLLTS
LLLTS is written in its own language. That is not decorative. It means our argument about
stricter AI engineering has to survive inside a real compiler, a real toolchain, and the stale fluorescent
misery of iterative work. If the rules are fake-deep, we feel it every day. If the required structure
is theater, the theater starts billing us by the hour.
That is exactly why the loop is valuable. We are not asking anybody to admire a manifesto from the outside. We are making the manifesto pick up its own hammer. If the language keeps helping while building itself, that is evidence. Not vibes. Evidence.
