Learning
000
Updated as I go — last pass August 2026

Learningin public

Everything I'm studying right now, in the open — notes, revision sheets, problem sets and drills. Not a reading list: these are working files I open every day, linked straight to the real thing.

5 tracks · 300+ notes · 217 problems mapped
01

System Design

50 topic notes · 217 problems · 5 revision sheets

The active track. The takeUforward roadmap broken into atomic notes, then every Codemia problem regrouped by shared architecture so there are 29 skeletons to learn instead of 217 problems to memorise. 50 of the 67 roadmap topics have notes.

BasicsLoad BalancingDataStoresConsistency vs AvailabilityMessage QueuesDevOpsCachingMicroservicesAPI GatewaysAuthenticationTrade-offsPractice ProblemsLow-Level Design
01

Pattern Map

All 217 Codemia problems grouped by architecture into 29 skeletons, one goal problem per family, plus a 14-problem shortlist that touches every skeleton. Progress saves in the browser. InteractiveCheckboxesDark / light
Open ↗
02

Core Roadmap Q&A

The whole roadmap as 67 questions across 12 sections, with a hide-answers self-test mode and a print stylesheet. 67 questionsSelf-testPrintable
Open ↗
03

HLD Revision Sheet

Fifty high-level design questions — scaling, storage, consistency, queues — for a fast pass before an interview. 50 questionsHigh-level design
Open ↗
04

LLD Revision Sheet

Fifty low-level design questions — class modelling, SOLID, design patterns, concurrency — the object-design half of the loop. 50 questionsOODDesign patterns
Open ↗
05

Uber — worked end to end

A full design in two printable pages: Redis geohash dispatch, the distributed lock, late Kafka offset commits, durable execution and geo-sharding. Geo dispatchKafka2 pages, A4
Open ↗
06

The 50 topic notes

One note per concept — consistent hashing, LSM-trees, CAP and PACELC, the transactional outbox, cache write policies, rate limiting — each with a worked example. Atomic notesCross-linked
Open ↗
07

Codemia Catalog

The full problem catalog — 127 system design, 70 OOD/LLD and 18 agentic AI — with the core twelve cross-marked. 127 SD70 LLD18 Agentic
Open ↗
08

Explained like you're ten

Every basic concept retold as one running pizza-shop story — the version I reach for when a definition hasn't stuck. Intuition firstNo jargon
Open ↗
09

The sprint plan

A day-by-day system-design schedule — what to read, what to draw, and what to be able to say out loud by the end of each day. Day-by-dayActive plan
Open ↗
02

AI System Design

20 parts · 167 chapters · 54 printed pages

The distributed-systems half of AI: retrieval architecture, agent topologies, inference cost, evaluation and safety. A twenty-part guide, of which six parts are fully written up as atomic notes so far.

FoundationsModel LandscapeTraining & AdaptationInference OptimizationPrompting & ContextRetrieval (RAG)Agentic SystemsMemory & StateFrameworks & ToolsDocument ProcessingInfrastructure & MLOpsSecurity & AccessReliability & SafetyEvaluation & ObservabilityAI Design PatternsCase StudiesTool Use & Computer AgentsVoice & AudioMultimodal GenerationInterview Prep
01

The complete guide

Twenty parts and 167 chapters in a single browsable file — from foundations through retrieval, agents, MLOps, safety and evaluation. 20 partsSingle fileSearchable
Open ↗
02

Printable edition

The same guide as a 54-page PDF for reading away from a screen. PDF54 pages
Open ↗
03

Retrieval systems

RAG fundamentals, chunking strategies, embedding models, vector databases, hybrid search, reranking, agentic RAG and GraphRAG. 9 notesHybrid searchGraphRAG
Open ↗
04

Prompting & context engineering

Fundamentals, few-shot and in-context learning, chain-of-thought, tree-of-thought, structured generation, DSPy optimisation and prompt-injection defense. 8 notesDSPyInjection defense
Open ↗
05

Training & adaptation

Pretraining basics, fine-tuning strategies, LoRA/QLoRA/PEFT, quantization, RLHF and DPO, RLVR and reasoning models, distillation, synthetic data. 8 notesLoRARLHF / DPO
Open ↗
06

Frameworks & tools

LangChain, LangGraph, LlamaIndex, DSPy, Semantic Kernel, AutoGen and CrewAI, LangSmith observability — plus a selection guide for choosing between them. 9 notesSelection guide
Open ↗
07

Case studies

Enterprise RAG, customer-support automation, a coding assistant, an autonomous coding agent, document intelligence, content moderation, real-time search, multi-tenant SaaS, financial analysis and a conversational agent. 10 designsEnd to end
Open ↗
08

Interview prep

A question bank spanning RAG, agents, optimisation and evaluation; answer frameworks (SPIDER, ETA, STAR-L); nine whiteboard exercises; and the common pitfalls to avoid. Question bankFrameworksWhiteboard drills
Open ↗
03

Agent Engineering

13 notebooks · 12 written up · 33 notes

The hands-on half — code I actually ran, then turned into notes. LangChain v1 and LangGraph end to end, plus the infrastructure around an agent: MCP servers, a model gateway, retrieval without a vector database, and evaluation.

01

LangChain v1 — master file

All seven notebooks condensed into one: create_agent, tools and the three-step execution loop, message types, structured output, middleware (summarization, human-in-the-loop) and a five-layer guardrail stack. AgentsToolsMiddlewareGuardrails
Open ↗
02

LangChain self-test

Sixty questions with collapsed answers and code drills — the check that the notes actually stuck. 60 questionsCode drills
Open ↗
03

LangGraph — five modules

StateGraph and the add_messages reducer, the ReAct back-edge, checkpointing with thread_id, interrupt() for human approval, multimodal RAG with CLIP, and sequential vs supervisor vs hierarchical multi-agent. StateGraphCheckpointersMulti-agent
Open ↗
04

MCP servers

Server, client and app roles; stdio versus HTTP transports; building one with FastMCP — how a model gets tools it didn't ship with. FastMCPTransports
Open ↗
05

LLM gateway

One API across providers, with routing, fallbacks, caching and cost tracking — an API gateway, but for models. LiteLLMFallbacksCost tracking
Open ↗
06

Vectorless RAG

Retrieval with no chunking, no embeddings and no vector database — build a tree index from the document's own structure and let the model search it. PageIndexTree search
Open ↗
07

Evaluation with LangSmith

Datasets and LLM-as-judge scoring — how to choose a model on evidence instead of vibes, and how to catch a regression before users do. DatasetsLLM-as-judgeTracing
Open ↗
08

The 11-hour course map

A timestamp map of the source video to the note that covers each section — including the gaps I haven't closed yet. TimestampedGap tracking
Open ↗
09

The source notebooks

The runnable originals — the LangChain v1 crash course and the agentic LangGraph course, thirteen notebooks in total. JupyterRunnable
Browse ↗
04

Certification

CCAR-P · 63 items · 7 domains

Preparing for Claude Certified Architect — Professional: 63 items, 120 minutes, 720 of 1000 to pass. I built a practice-exam engine that samples the real blueprint weights and teaches the topic on the spot when I get one wrong. Six of the seven domains have notes; Domain 6 is the open gap.

1 · Solution Design & Architecture — 17%2 · Models, Prompting & Context — 13%3 · Integration — 19%4 · Evaluation, Testing & Optimization — 16%5 · Governance, Safety & Risk — 14%6 · Stakeholder Comms & Lifecycle — 14%7 · Developer Productivity — 7%
01

Daily practice exam

A generated paper — multiple-choice and multiple-response — scored on the real scale, with an explanation for the right answer and for why each distractor is wrong. Auto-scoredTeaches on missScaled 100–1000
Take it ↗
02

Blueprint & gap analysis

The seven domains with their exam weights, mapped against what the vault actually covers — so revision goes where the gap is, not where it's comfortable. 7 domainsWeightedHonest gaps
Open ↗
03

AI Fluency framework

Anthropic's course hub — Delegation, Description, Discernment and Diligence, with per-lesson notes. 4 DsPer-lesson notes
Open ↗
04

AI Fluency glossary

The vocabulary in one place — the four Ds and their sub-skills, interaction modes, and the technical and prompting terms underneath them. TerminologyQuick lookup
Open ↗
05

Claude Code course

How an agentic coding tool actually works — the agent loop, context compaction, permission modes — and the Explore → Plan → Code → Commit workflow. Agent loopPlan mode3 lessons
Open ↗
05

Reference Library

The whole vault, browsable

The machinery underneath: every note in one searchable file, the catalog, the running log, and the honest scorecard of what's still missing.

01

Complete notes

The entire vault rendered into one navigable page with a sidebar — system design, AI engineering, courses, plans and logs. Single fileSidebar navDark / light
Open ↗
02

Vault index

One line per page — summary, track and status — the table of contents for everything above. CatalogCross-linked
Open ↗
03

Readiness gap analysis

An unflattering audit of the same material — where the topics are right, where the evidence is thin, and what has to exist before it counts. HonestGap-driven
Open ↗
04

Progress & log

Hours per track against the plan, recomputed each session, with an append-only log of what actually happened. Per-trackAppend-only log
Open ↗
05

Markdown export

The whole system-design set as plain markdown — portable, greppable, and easy to paste anywhere. Plain textPortable
Open ↗