Curriculum Roadmap: Beginner to Expert

The full map: 5 levels × 20 tracks, plus specialist electives. Use it to see where you are, what comes next, and what "expert" actually means in each area.

All levels15 minLast updated 2026-10-08

How the curriculum is designed

Expertise in AI is not one skill. It is a stack of skills, from using tools well, to building with models, to understanding what happens inside them. The curriculum is organised in two dimensions:

Levels (vertical): how deep you go. Every level has the same structure: concepts, practice, labs, checkpoint.
Tracks (horizontal): the subject area. Each track runs through all five levels, so you can see how a topic grows from "what is it" to "I can design and teach this".

Each level is broader and deeper than the one before. Nothing in a higher level assumes knowledge you have not met yet.

What each level means

Level	You can…	Typical time	Proof of skill
L1 Foundations	Explain core AI concepts in plain words. Prompt well. Use chat, inline and agent modes in your IDE. Write an `AGENTS.md`. Connect an MCP server. Spot hallucinations.	15–25 h	Labs + checkpoint quiz ≥ 80%
L2 Practitioner	Use AI as a daily multiplier. Call LLM APIs from Scala/Python with structured output. Build a simple RAG. Write skills and custom agents. Use AI for tests, reviews and refactors safely.	40–60 h	Ship a small AI-powered tool used by someone else
L3 Advanced	Build agents and MCP servers from scratch. Design evals. Fine-tune small models. Deploy, monitor and cost-optimise LLM features. Defend against prompt injection.	80–120 h	A production-grade agent or MCP server with evals and guardrails
L4 Expert	Explain and implement transformer internals. Understand pre-training, post-training and inference optimisation. Choose architectures and make trade-offs at system level.	120–200 h	Implement a mini-GPT, serve and benchmark it, write a design doc
L5 Master	Read and reproduce papers. Work on interpretability/alignment, multimodal and on-device AI. Lead AI strategy and adoption, mentor others.	Ongoing	Publish, teach, or lead an AI initiative

The 20 tracks across 5 levels

Read a row left to right to see how a topic grows. Read a column top to bottom to see everything in one level.

Track	L1 Foundations	L2 Practitioner	L3 Advanced	L4 Expert	L5 Master
1. AI & ML foundations	AI vs ML vs DL vs GenAI; learning types; history	Classical ML (regression, trees, clustering); metrics; overfitting	Neural nets, backprop, optimisers; PyTorch basics	Linear algebra, probability, information theory for ML	Learning theory, scaling laws, open problems
2. LLMs & internals	Tokens, embeddings, attention (intuition), training vs inference	Model families, sizes, open vs closed, benchmarks, pricing	Architectures: decoder-only, MoE, long-context, SSMs	Implement a transformer; KV cache; positional encodings	Interpretability, emergent behaviour, frontier research
3. Prompt engineering	Prompt anatomy; zero/few-shot; roles; iteration	Structured output (JSON/schemas); chaining; templates	Prompt optimisation; DSPy-style programmatic prompting	Prompting reasoning models; meta-prompting at scale	Prompt research; automatic prompt discovery
4. Context engineering & memory	Context window; what to include; @-mentions; rules files	Context budgeting; summarisation; long docs	Memory architectures; compaction; context isolation in multi-agent	Long-context internals; retrieval vs context trade-offs	Novel memory systems
5. AI-assisted coding (IDE)	Completion, chat, inline edit, agent mode in VS Code / IntelliJ / Xcode	Agentic workflows: plan-act-verify; TDD with AI; refactors; reviews	Background/cloud agents; parallel agents; CI integration	Designing AI-native dev platforms; measuring impact	Building coding agents and dev tools
6. Customisation	AGENTS.md, instructions, rules, prompt files, skills (concepts)	Authoring skills & custom agents; hooks; team conventions	Plugin packaging; skill libraries; governance of shared configs	Org-wide AI platform configuration	Contributing to open standards
7. Agents & agentic systems	Agent loop; tools; autonomy levels; supervision	Using agents for multi-step tasks; subagents; planning modes	Build agents from scratch; multi-agent patterns; frameworks	Reliability engineering for agents; long-horizon tasks	Agent research; self-improving systems
8. MCP & tool integration	What MCP is; hosts/clients/servers; tools/resources/prompts	Configuring MCP servers; function calling; choosing servers safely	Build MCP servers (Python, JVM/Scala); auth; transports; ACP/A2A	Designing tool ecosystems; gateways; enterprise MCP	Protocol design & contribution
9. RAG & knowledge	What RAG is and why	Embeddings; chunking; vector DBs; a first RAG	Hybrid search; re-ranking; GraphRAG; agentic RAG; RAG evals	Retrieval at scale; latency/quality trade-offs	New retrieval paradigms
10. Building with LLM APIs	First API call (Python & Scala)	Streaming, tool calling, structured output, retries, cost	Production patterns: caching, routing, fallbacks, batching	Gateway/platform design; multi-provider abstraction	—
11. Model customisation	Pre-training vs fine-tuning (concept)	When to fine-tune vs prompt vs RAG	LoRA/QLoRA; datasets; distillation; quantisation	SFT, RLHF, DPO, RL from verifiable rewards	Training frontier-style models
12. Evaluation & quality	Verifying outputs; why "it looked right" is not enough	Golden sets; manual evals; regression prompts	LLM-as-judge; eval pipelines; A/B; agent evals	Benchmark design; contamination; statistics	Eval science research
13. LLMOps & deployment	Cloud vs local models; cost basics	Local models (Ollama, LM Studio, MLX); tokens & cost tracking	Observability, tracing, guardrails, rate limits, SLAs	Inference serving (batching, speculative decoding, vLLM-style)	Hardware, accelerators, efficiency research
14. AI security	Secrets, data leakage, prompt injection (intro)	Safe tool permissions; sandboxing; supply chain of AI tools	Threat modelling LLM apps; OWASP LLM Top 10; red-teaming	Secure agent architectures; model supply chain	Adversarial ML research
15. Responsible AI & governance	Bias, privacy, IP, honesty, over-reliance	Company policies; licences; attribution	Risk assessments; documentation (model cards)	Regulation (e.g. EU AI Act) and compliance design	Policy, standards, alignment
16. Data & analytics with AI	AI for SQL, spreadsheets, quick analysis	AI for Spark (Scala/PySpark), pipelines, data quality	LLMs in data pipelines; text-to-SQL; semantic layers	Data for training: curation, synthetic data	—
17. AI across IT	DevOps, QA, SRE, security, docs, PM: overview	AI in CI/CD; AI-written tests; incident analysis	AIOps; automated remediation agents with guardrails	Org-wide AI operating model	—
18. Multimodal & on-device	Images, audio, video models (overview)	Vision in dev work (screenshots, diagrams, UI)	Speech pipelines; on-device with Core ML / MLX	Multimodal architectures; diffusion models	On-device research; world models
19. Learning & career with AI	AI as tutor; learning techniques; daily habits	Personal knowledge systems; deliberate practice with AI	Teaching others; building a portfolio	Becoming the go-to expert	Mentoring, writing, speaking
20. Product, research & leadership	What AI is good and bad at	Spotting good AI use-cases; UX of AI features	AI product design; human-in-the-loop design	Strategy, build vs buy, ROI measurement	Research reading/reproduction; leading AI teams

Level 1: Foundations (Phase 1, available)

Goal: understand the vocabulary and mental models, and use AI tools productively and safely in daily development work.

Level 2: Practitioner (Phase 2, available)

Goal: AI becomes a reliable daily multiplier, and you can build small AI-powered tools yourself. Running example: a retail Store Assistant.

Level 3: Advanced (available)

Goal: design and build robust AI systems: agents, tool servers, evaluation, deployment and security.

Building MCP servers in Python (official SDK) and on the JVM (Java SDK used from Scala): tools, resources, prompts, auth, testing with an inspector.
Building agents from scratch: the loop, tool schemas, state, memory, error recovery, stopping conditions. Then frameworks and when to avoid them.
Multi-agent systems: orchestrator-worker, planner-executor, critics, handoffs, agent-to-agent protocols (A2A, ACP).
Evals: golden datasets, rubric grading, LLM-as-judge pitfalls, agent trajectory evaluation, regression suites in CI.
Advanced RAG: hybrid BM25 + vector, re-rankers, query rewriting, GraphRAG, agentic retrieval.
Fine-tuning: LoRA/QLoRA, dataset building, overfitting, distillation, quantisation, evaluation before/after.
LLMOps: tracing, observability, caching, model routing, cost dashboards, guardrails, rate limiting.
AI security: prompt injection (direct/indirect), data exfiltration, tool poisoning, sandboxing, OWASP Top 10 for LLM apps, red-teaming.
Level 3 Labs: eight hands-on labs, one per page.
Capstone: a production agent with a custom MCP server, an eval suite, observability and a security review.
Level 3 Checkpoint Quiz: 20 questions across the level.

Level 4: Expert (available)

Goal: understand the machinery: how models are built, trained and served, and make architecture-level decisions.

The maths you actually need: vectors, matrices, gradients, softmax, cross-entropy, probability — all in runnable code.
Transformer internals: attention from scratch, multi-head, layer norm, residuals, positional encodings, a tiny GPT.
Training and post-training: pre-training data, SFT, RLHF, DPO, RLVR, constitutional approaches.
Inference optimisation: KV cache, batching, paged attention, speculative decoding, quantisation, serving engines.
Reasoning models and test-time compute: CoT, self-consistency, verifiers, effort dials, when "thinking" helps.
AI-native architecture: the gateway pattern, build vs buy, platform teams, cost/reliability.
Governance: EU AI Act risk tiers, model risk management, documentation, paved paths.
Level 4 Labs: seven labs — implement attention, train a tiny GPT, benchmark serving.
Capstone: mini-GPT trained, quantised, served, benchmarked, plus a design document.
Level 4 Checkpoint Quiz: 20 questions across the level.

Level 5: Master & Specialist (available)

Goal: push the frontier in a chosen speciality and multiply others.

Research skills: read a paper in three passes, reproduce results, run ablations, write up findings.
Interpretability and alignment: probing, sparse autoencoders, circuits, reward hacking, scalable oversight.
On-device AI: Apple silicon, Core ML, MLX, on-device foundation models, privacy-preserving design.
Multimodal: vision-language models, speech (ASR/TTS), diffusion, video.
Leadership: AI adoption playbooks, measuring productivity honestly, training teams, policy writing.
Level 5 Labs: five open-ended labs producing real artefacts.
Capstone: choose a speciality project and publish it (blog, talk, open-source, paper).
Level 5 Checkpoint Quiz: 15 questions across the level.

Specialist electives (niche but valuable)

These go deep on narrow topics. Pick them up whenever you meet them at work.

Functional programming & AI

Typed effect systems (Cats Effect, ZIO) for agent orchestration; why strong types make AI code safer.

Text-to-SQL & semantic layers

Getting correct SQL from natural language. Schema grounding and validation.

Code search & code intelligence

LSP, symbol graphs, tree-sitter, embeddings for code. How IDE agents "see" your repo.

Synthetic data

Generating test data, eval sets and training data, and how to avoid model collapse.

Structured generation

Constrained decoding, grammars, JSON-mode internals.

AI for legacy modernisation

Migrating Java to Scala 3, Scala 2 to 3, monolith to services, with agents and tests as a safety net.

Accessibility & AI

Using AI to build accessible UIs, and AI as an assistive technology.

Edge & embedded AI

TinyML, quantised models on devices, latency budgets.

AI for documentation

Docs-as-code, keeping docs in sync with code, generating diagrams.

Recommender systems

Classic and LLM-era recommendation, ranking, embeddings at scale.

Time-series & forecasting

Classical methods, foundation models for time series.

AI economics

Token pricing, cost per task, latency vs quality vs cost trade-offs.

Suggested study plans

Plan	Time per week	Route
Steady	3–4 h	One L1 page every 2–3 days, labs at the weekend. L1 done in about 6 weeks.
Focused	8–10 h	L1 in 2–3 weeks, L2 in about 6 weeks. Start using agents at work from week 1.
Daily developer	30 min/day + real work	Read a page in the morning and apply it to that day's ticket. Keep a learning log (see page 13).