Kaddo

Knowledge Driven Development for software teams working with humans and AI.

Kaddo is an open-source toolkit that helps software projects keep product knowledge close to the code.

It combines a deterministic CLI with reusable LLM agent prompts so teams can understand, document, evolve, and protect project knowledge without turning documentation into bureaucracy.

Kaddo helps new, pre-AI, and legacy projects build a living knowledge layer inside the repository.

It supports workflows such as:

• initializing project knowledge,
• scanning technical signals,
• preparing context for LLM chats,
• guiding architecture and capability discovery,
• turning roadmap ideas into traceable Work Items,
• connecting knowledge artifacts to code ownership,
• detecting possible knowledge drift,
• explaining the current state of a project,
• mapping multirepo systems as modules.

The core idea is simple:

The CLI does deterministic work. The LLM helps with interpretation. The human confirms. The knowledge stays versioned with the code.

Modern software teams increasingly use AI to build and evolve systems, but many projects lack the structured context needed for AI-assisted work to be safe, useful, and aligned with product knowledge.

Kaddo helps answer questions like:

• What does this project do?
• What capabilities does it support?
• What architecture is currently known?
• What should we build next?
• What code is related to this decision or Work Item?
• Did the code change without updating the knowledge artifact?
• How do we onboard humans and AI agents with the same context?

Kaddo follows a few non-negotiable principles:

• Deterministic CLI: the CLI does not call LLMs.
• No API key required: Kaddo works locally and stores artifacts in your repo.
• Human-controlled LLM usage: you run agent prompts in your own chat or AI tool.
• Minimum sufficient knowledge: capture what is needed, not everything.
• Guard is non-blocking: Kaddo warns about possible drift, but does not block by default.
• Ownership is explicit: knowledge-to-code mapping is declared through artifact front matter.
• Progressive knowledge: add modules, templates, agents, and artifacts only when needed.

A typical Kaddo workflow looks like this:

kaddo init
kaddo scan
kaddo context
kaddo add agents
kaddo understand

Then you use the generated context and agent prompts in your preferred LLM chat to create artifacts such as capabilities, architecture, and roadmap.

After that, Kaddo helps you continue the loop:

kaddo create --from roadmap
kaddo owners suggest
kaddo guard
kaddo explain

For multirepo systems:

kaddo modules map
kaddo modules list

Kaddo stores knowledge in versioned files such as:

.kaddo/
  config.yml
  scan.json
  context-pack.md
  understand.md
  explain.md

architecture/
  inventory.md
  capabilities.md
  current-state.md
  roadmap.md
  work-items/
  agents/
  modules/

These artifacts are designed to be readable by humans, useful for LLM agents, and close enough to the code to stay maintainable.

Kaddo is not:

• a SaaS platform,
• a dashboard,
• an autonomous coding agent,
• a replacement for human review,
• a project management tool replacement,
• a tool that secretly calls LLMs,
• a strict governance framework.

Kaddo is a lightweight knowledge layer for software evolution.

This organization contains the Kaddo ecosystem:

• Kaddo CLI — the deterministic command-line toolkit.
• Kaddo Docs — documentation, guides, examples, and visual workflows.
• Examples — reproducible scenarios for new, pre-AI, legacy, and multirepo projects.
• Templates and agents — reusable structures and prompt packs for Knowledge Driven Development.

Kaddo is useful for:

• software architects,
• tech leads,
• developers,
• platform teams,
• product-minded engineering teams,
• teams modernizing legacy systems,
• teams adopting AI-assisted development,
• open-source maintainers who want better project context.

Kaddo aims to make software projects easier to understand, safer to evolve, and better prepared for AI-assisted development.

The goal is not to document everything.

The goal is to help a project remember the knowledge that matters.

Knowledge, connected.