The framework

Knowledge as Code is a way of keeping engineering knowledge: plain Markdown in git, where every document has a type and every type declares a schema. kac is the tool that checks a corpus against that schema. This section is the framework itself, meaning the ideas the tool serves rather than the commands serving them.

A corpus is one repository of knowledge records, with the schema it runs. Every corpus takes the same framework and fills it with its own knowledge.

The pages here

• Principles says why the framework is shaped the way it is, and what the design will not trade away.
• Taxonomy says what a type and a tier are, what the four tiers ask, and the shape a type takes on disk.
• The default types introduces every type that ships, grouped by tier, one line each.
• Metadata says what a record has in frontmatter, how ids are formed, and how a citation reaches a part of one.
• Contributing says how knowledge is added, reviewed and merged, and where the rules for the words themselves live.
• Automation says what a pipeline does for a corpus, and what it leaves alone.
• Lineage says how the types relate to their prior art, and on what terms.

What a corpus has beside these

Four pages travel with each corpus as well. Three of them have tables generated from the types that corpus adopted, so a corpus that took five of the framework's types gets five rows, each linking to a page it holds. Contributing has no generated block. It is the way in, and what a corpus adds locally.

In the corpus	What it answers
Taxonomy	which types this corpus adopted, and where a record goes
Metadata	which fields this corpus's own types carry
Lineage	the prior art behind each type this corpus adopted
Contributing	the way in to all of the above, and anything the corpus asks locally

Each sits under knowledge-as-code/ in the corpus, beside a root page that is the way in. Every one of them is the narrow, corpus-facing half of a page here.