AI Knowledge Bank — Overview
This is the knowledge bank: what I should know as an AI applications engineer — general theory for all AI notes going forward, organised as a three-tier progression. It is paired with the Learnings folder: what I actually did — the decisions I made, things I discovered, and mistakes I hit and fixed.
The two are linked both ways: a concept links down to any of my implementations via a Related implementations line, and each learning links up to the concept it relates to.
What belongs where: Knowledge bank = generic theory, true regardless of any one project. Learnings = my concrete record on a real project. Keep implementation detail out of the theory; link to it instead.
The three tiers
| Tier | For | Covers |
|---|---|---|
| 01 · Foundations | The beginner concepts you need before anything else makes sense | tokens, context windows, embeddings, temperature, model routing, why RAG exists, structured outputs, prompt anatomy, what an agent actually is |
| 02 · Intermediate | The builder concepts — how real systems are put together and tuned | RAG design & tuning, chunking, vector-DB tradeoffs, evals, agent patterns (ReAct, state machines, tool use), cost management, prompt versioning, context engineering, observability, multi-model orchestration, provider adapters & gateways |
| 03 · Expert | The production/systems concepts that separate a demo from a service | multi-agent tradeoffs, prompt caching, security & guardrails, graceful degradation, MCP, scaling, when not to use AI, human-in-the-loop design |
Read them in order once. After that, use them as a lookup — jump to the concept you need.
The build loop
The cycle this knowledge base runs on:
- Build something (on the Data Patch Agent or anything else) and record it in Learnings.
- Tell the assistant what you learned, decided, or fixed.
- The assistant analyses it against the reference and does one of three things:
- Not covered yet → researches the theory (with sources) and adds it to the right tier, then links your learning under Related implementations.
- Covered and aligned → doesn't rewrite theory; just adds a Related implementations link to your learning.
- Covered but your approach diverges → flags it and explains why, and you still choose whether to log it.
The full mechanics live in ASSISTANT_PROMPT.md.
Related-implementations index
A roll-up of every concept that currently has one of my implementations linked to it. Grows as learnings accumulate; concepts with nothing built yet aren't listed.
The committed stack
Absorbed from the old roadmap: the tools this practice standardises on, so you stop tool-shopping and start building.
| Layer | Choice |
|---|---|
| Runtime | Claude Code / Copilot Agent Mode |
| Context & prompts | Markdown — CLAUDE.md, version-controlled prompt files |
| Structured outputs | Pydantic (Python) / JSON schema + Zod (TS) |
| Vector store | Postgres + pgvector |
| Models | Claude Sonnet (reasoning-heavy) + Haiku (cheap classification) |
| Evals | Hand-rolled: golden set + LLM-as-judge |
| Observability | Langfuse (free tier) |
| Docs | this Docusaurus repo |
Deliberately avoided for the flagship: LangChain / CrewAI / AutoGen — hand-write the loop so you understand it.
Companion documents
The reference book explains the concepts. These go deeper on specific things and are linked from the tiers rather than duplicated:
- Glossary — fast lookup for any term. Skim once, return when a word trips you.
- Building an Agentic System — the step-by-step build recipe (the how-to).
- AI-First Methodology — the six components of an AI-first engineering practice.
- Reading List — the essays and sources behind this book.
- Open Questions — things not yet fully understood; the inbox for future reference sections.