LDD is a methodology for preserving decision lineage in AI-assisted development.
Instead of preserving entire conversations, LDD focuses on preserving:
- Human intent
- Decisions
- Evidence
- Open questions
so that future AI sessions can continue reasoning without starting from zero.
Git manages code lineage.
LDD manages decision lineage.
AI output is reproducible.
Human intent is fragile.
A methodology for preserving decision lineage in AI-assisted development.
Draft Specification v0.1
Author: Tomohiro Momose Started: June 2026
Lineage-Driven Development (LDD) is a development methodology for the age of AI-assisted software engineering.
Modern AI systems can generate code, explain architectures, debug problems, and accelerate development.
Yet they introduce a new challenge:
reasoning disappears.
Chat sessions end. Context windows overflow. Threads are abandoned. New conversations begin with no memory of why previous decisions were made.
Code survives.
The reasoning behind the code often does not.
LDD is an attempt to solve this problem.
Most attempts to preserve AI collaboration focus on saving conversations.
LDD starts with a different question:
What does the next AI actually need to know?
The answer is often surprising.
Not the previous AI's response.
Not the full conversation history.
But the human intent that drove the conversation.
AI-generated explanations can be recreated.
Original human intent often cannot.
This leads to the central assumption behind LDD:
AI output is reproducible.
Human intent is fragile.
Therefore:
Preserve intent before conversation.
Preserve decisions before explanations.
Modern AI-assisted workflows suffer from recurring failures:
- Long conversations become unusable.
- Context windows eventually collapse.
- New sessions lose critical history.
- Teams cannot reconstruct past reasoning.
- Important decisions are buried inside thousands of messages.
- The same investigations are repeated multiple times.
Developers lose far more than chat history.
They lose lineage.
A lineage is the traceable history of how a decision emerged.
Problem
↓
Intent
↓
Investigation
↓
Decision
↓
Evidence
↓
Implementation
↓
Future Work
LDD treats this lineage as a first-class development artifact.
The goal is not merely to preserve information.
The goal is to preserve reasoning.
Months later, a developer should still be able to answer:
- Why was this chosen?
- What alternatives were considered?
- What evidence supported the decision?
- What assumptions were made?
- Are those assumptions still valid?
Traditional conversation storage treats all messages equally.
LDD does not.
Not all information has equal value.
Human input is often primary information.
AI responses are often derived information.
For this reason LDD favors asymmetric compression:
Preserve with minimal loss whenever possible.
Compress into:
- Decisions
- Rationale
- Evidence
- Open Questions
- Next Actions
The objective is not to reproduce conversations.
The objective is to preserve decision-making capability.
LDD intentionally rejects the idea that every conversation must be preserved.
The goal is not historical reconstruction.
The goal is reasoning continuity.
A future AI can regenerate explanations.
It cannot reliably regenerate original human intent.
LDD is not a conversation archival system.
It is a decision lineage system.
Hydrate is the central operation of LDD.
A new AI conversation should not start from zero.
Instead, it should inherit the lineage of previous work.
Hydrate reconstructs usable context from prior decisions and injects it into a new thread.
Importantly:
Hydrate does not attempt to restore every message.
Hydrate attempts to restore understanding.
The desired outcome is:
Different conversation
Same reasoning continuity
Every meaningful development activity should answer:
Why did this begin?
What conclusion was reached?
What supports the decision?
What remains unresolved?
What should happen next?
Together these form a transferable unit of lineage.
| Concept | Meaning |
|---|---|
| Intent | What the human is trying to achieve |
| Decision | A conclusion reached during development |
| Evidence | Information supporting a decision |
| Open Question | Unresolved uncertainty or investigation |
| Action | The next meaningful step |
| Hydrate | Reconstruction of usable context |
| Lineage | The chain connecting intent, decisions, and outcomes |
Definitions are evolving and will be formalized in future specification drafts.
Traditional software development assumes context is effectively unlimited.
AI-assisted development proves otherwise.
LDD treats context as a constrained resource that must be actively managed.
This leads to concepts such as:
- Context Refresh
- Context Hydration
- Context Compression
- Context Recovery
- Context Health
Healthy workflows continuously convert temporary conversations into durable lineage.
LDD complements existing engineering practices.
It does not replace them.
| Practice | Purpose |
|---|---|
| Git | Code lineage |
| ADR | Architectural decisions |
| Issues | Task tracking |
| Documentation | Knowledge sharing |
| LDD | Decision lineage across AI collaboration |
LDD can coexist with:
- Agile
- Scrum
- Kanban
- Waterfall
- Solo Development
- AI-Native Development
LDD is a methodology.
Not a product.
It can be practiced manually.
A minimal implementation may consist of:
- README
- ADRs
- Backlog
- Development Journal
- Context Transfer Documents
The process matters more than the tooling.
Tools automate LDD.
They do not define it.
Current implementations:
- Lineage (experimental reference implementation)
Future implementations may include IDE plugins, developer tools, and enterprise platforms.
LDD is not:
- A replacement for Git
- A prompt engineering framework
- A memory system that stores everything
- A task management methodology
- A knowledge-base product
LDD focuses on a single challenge:
Preserving and transferring decision lineage in AI-assisted development.
Draft Specification v0.1
This repository represents an early research proposal.
The terminology, structures, and practices described here are expected to evolve through experimentation and community feedback.
The software industry learned how to preserve code.
The next challenge is preserving reasoning.
Git gave us source control.
LDD aims to give us decision control.
Because software is not merely the evolution of code.
It is the evolution of decisions.
This specification is licensed under CC BY 4.0.