Software that explains itself, by design.
Understood, scalable, fast, cheap, and built to last. The five problems LDD solves at once.
What LDD solves
The most powerful AI development methodology.
Spec-driven docs, agile rituals, agentic loops: every other methodology closes one of these and leaves the rest. LDD is the first that closes all five at once.
Understanding
The code is never a black box.
The reasoning lives beside the implementation, in plain language a new engineer, an auditor and the AI can all read. Reviews become reading, and every error points back to the line that caused it.
error → its source line
Everywhere else: the reasons live in a few people's heads, not in the code.
Complexity
Vast systems, held in the mind.
Named concepts break the biggest system into parts sized for a person, and it stays that way as it grows, because it was written to be read. New engineers are productive in days.
one system
named concepts
Everywhere else: the system outgrows the people, and nobody holds it whole.
Speed
Generation at the speed of AI.
The model drafts the reasoning and the code together, so the explanation keeps pace with the output. You move fast without ever losing the thread of why.
one pass, together
Everywhere else: AI writes faster than anyone can read, and the debt compounds at machine speed.
Cost
Building software costs a fraction.
Writing was never the expensive part. LDD spends the cheap thing, writing, to protect the expensive one, understanding. What you keep is an asset, not code you will pay to untangle.
spend the cheap one to protect the costly one
Everywhere else: the money goes to rework, onboarding and rediscovering what was already known.
Craft
Technology as a work of art.
Intent, prose and code become one document, so software stops being disposable output and becomes something made to last. The same source yields the book a person reads and the program a machine runs.
they cannot disagree
Everywhere else: throwaway output, and every rewrite starts from nothing.
The definition
Literate Driven Development is AI-assisted software authorship, with Literate Programming at its core. You write the reasoning once, and it becomes the shared context a person and a model both build from.
One authored source becomes the documentation your team reads and the code your machines run, and the shared context your AI works from. No drift. No black boxes. No knowledge lost when people leave.
Case studies
Real systems you can run, and read.
Hard, real software built end to end with LDD. Each one legible front to back.
kcc: a C compiler, written as literature.
Reads C17, emits native ARM64, and boots a Linux kernel, self-hosting to a byte-identical binary.
Built by one person on a $100/mo Claude Code subscription, powered by Claude Opus 4.8, using the LDD methodology.
Read the kcc case study →
LDD-Audio: a desktop audio editor, in three days.
A non-destructive, real-time DAW with a live mixer, spectral analysis, time-stretch and recording.
Written once, as an LDD narrative. From that one weft source came the C++, its tests, and a 228-page book.
Read the LDD-Audio case study →
Literate Driven Development vs. every other way to build software.
It all comes down to one question: where does the source of truth live? In every other approach the explanation and the code eventually drift apart, and the code wins. In Literate Driven Development they are one artifact, so they can never fall out of sync. Read the five rows below and see where each method leaves you.
| TraditionalCode-first | VibeAI, prompt-to-code | Spec-DrivenAI, spec-first | Agentic LoopAI, iterate-to-green | Literate DrivenAI, narrative-first | |
|---|---|---|---|---|---|
| Source of truth | The code; docs drift | The prompt, then gone | A spec beside the code | Whatever turns tests green | The document is the code |
| What survives | Code without its reasons | Output only | Two artifacts, out of sync | Code no one has read | A narrative that explains itself |
| Human understanding | Reverse-engineered later | A black box | Trust the spec still holds | Opaque by construction | Read it like a book |
| Where the AI reads context | Scattered across files | The last prompt | A doc that already drifted | Trial and error | The very source you wrote |
| Behavior at scale | Entropy wins | Collapses fast | Spec bloat, drift widens | Unbounded, unreviewable | Legible by design |
The foundation
“Let us change our traditional attitude to the construction of programs. Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do.”
What is required
What's required?
Literate .weft files
The narrative sources where prose and code live as one document.
weft, the command line tool
It weaves the source into a document to read, and tangles it into the code to run.
Download weft on GitHubThe literate-driven-development skill
So the AI writes in the paradigm alongside you.
And a completely different way of programming.
The first three you install. This one you adopt, and it is the one that decides whether the other three are worth anything.
Services
If LDD can build a C compiler, it can de-risk your stack.
We ship ambitious software for a fraction of the cost, and hand you a system that stays legible for the people and the AIs that build it. One source of truth: woven into documentation, tangled into code, proven in production.
For the AI industry
Make AI output safe to ship
AI writes code faster than anyone can read it. LDD gives your models a written source of intent to build from, so what they generate stays legible, reviewable, and safe to ship at scale.
For industry at large
Software that survives its authors
When your people leave, the knowledge shouldn't. LDD turns review, onboarding, and audits into reading: one legible source of truth that stands up to technical, operational, and regulatory scrutiny.
What we do
Literate development
Craft and SpeedWe build your system in LDD from day one. You get shipping code and a readable book of why, never throwaway output.
Migration to literate
Understanding and ComplexityWe turn critical legacy into a legible web, recovering lost intent and retiring documentation debt for good.
AI-context engineering
Speed and UnderstandingWe turn your source into the high-fidelity context your models read and extend: less drift, fewer black boxes, output you can trust.
Legibility and governance audits
Understanding and CostWe make your system auditable: every decision traceable to the prose that justified it, ready for technical and regulatory review.
Team enablement
CraftTraining, tooling, and templates so your engineers author, weave, and tangle with confidence: LDD as a working discipline, not a demo.
Cost-down delivery
Cost and SpeedTeams-and-years ambition, delivered for a fraction. Our proof: a kernel-grade C compiler, built by one person on a $100/mo subscription.
Ready to de-risk your codebase?
Whether you're shipping AI-generated code or maintaining systems that must outlast their authors, we deliver it legible by design, from the first line.
Let's talk.
Interested in Literate Driven Development: a live demo, an interview, or a possible collaboration? Send a message and I'll get back to you.
