Interactive tutorials
Build with LLMs, agents & AWS
Forty-one self-contained, hands-on guides β from the transformer under the hood to a fridge that reasons about groceries and orders them itself. Each runs in the browser: dark mode, copyable code, and a knowledge-check quiz.
Building LLM Applications
LangChain, LangGraph & LangSmith organized around the three problems you hit as an app grows: glue code, non-linear logic, and observability. Includes RAG, a full agent, and a support-agent capstone.
Start learningHow LLMs & Transformers Work
The forward pass, end to end: tokenization, embeddings, self-attention, the transformer block, and how sampling turns logits into the next token β the machinery every LLM app sits on top of.
See inside the modelPrompt & Context Engineering
Get the most from a model without training it: prompt anatomy, few-shot & chain-of-thought, structured output, prompt caching, and context engineering β what to put in the window and what to leave out.
Write better promptsHow Embedding Models Work
Turning text into vectors: what an embedding is, how models learn the space (contrastive training), similarity metrics, and how to choose & use one well β the engine under semantic search.
See the mechanismTensorFlow
Google's end-to-end ML platform: the problem it solves, how it works (tensors, graphs, Keras, autodiff), its unmatched deployment reach (server, mobile, browser, TPU), limits, and vs PyTorch.
Learn TensorFlowPyTorch
The research-favorite framework: dynamic, pythonic define-by-run graphs, autograd, explicit training loops, the Hugging Face ecosystem, its limits, and when to pick it over TensorFlow.
Learn PyTorchKnowledge Distillation
Teach a small student model to imitate a big teacher: the core idea & "dark knowledge", soft targets & temperature, the distillation loss, response/feature/relation-based knowledge, offline/online/self schemes, and distillation in the LLM era (DistilBERT, sequence-level & reasoning distillation).
Compress the modelQuantization & Pruning
Make a trained model small and fast: quantization lowers the bits per weight (FP32βINT8/INT4, scale & zero-point, PTQ vs QAT), pruning removes weights (unstructured vs structured, the pruneβfine-tune loop). Why structure decides real speedups, compressing LLMs (GPTQ, AWQ, GGUF, QLoRA), and the compression stack.
Shrink & speed upLab: Train a Licence Recognizer
From scratch, no ML experience needed: label images, train YOLO weights, and read the fields off NZ/AU driver licences β with OCR, an API, and the privacy guardrails ID work demands.
Start the labHow YOLO & Label Studio Work
The two tools behind the lab, opened up: YOLO's one-pass detection architecture (backbone β neck β head β NMS) and the Ultralytics API, Label Studio's config/annotate/export model, and the label β train loop.
See how they workRAG vs CAG vs GraphRAG
How to ground a model in your data: retrieve at query time (RAG), preload & cache a small stable corpus (CAG), when to mix them, and GraphRAG plus the wider family (hybrid, reranking, HyDE, Agentic/Corrective/Self-RAG).
Compare methodsFine-tuning vs RAG vs Prompting
Three levers to adapt a model β and which to pull when: prompting changes how you ask, RAG changes what it knows now, fine-tuning changes how it behaves. A decision flow, trade-offs, and how to combine them.
Choose the leverVector Databases Compared
Where embeddings live and how nearest-neighbour search works β the ANN problem, then Chroma, FAISS, Qdrant, Pinecone, pgvector, Weaviate & Milvus compared, with a landscape map and when to choose which.
Compare storesLangChain vs LlamaIndex
Which framework to build on: LangChain's breadth (agents, orchestration) vs LlamaIndex's depth on data (ingestion, indexing, retrieval) β where they overlap on RAG, and when to use each or both.
Compare frameworksLLM Evaluation & Observability
Prove it works and keep it working: eval datasets, offline vs online evals, LLM-as-judge, tracing & observability, what to measure, and the eval loop that turns every failure into a permanent test.
Measure & monitorAgent Development Kits
Google ADK vs AWS Strands + Bedrock AgentCore vs LangGraph β what problem each solves, its limits, and when to choose it, in a clear Problem β Solution β Limits format.
Compare kitsAutoGen vs CrewAI
The two leading multi-agent frameworks compared: conversable agents vs role-based crews, their orchestration models, the same task coded both ways, a head-to-head table, and how to characterise the work to choose.
Compare frameworksAnthropic Agent Architectures
From Building Effective Agents: the augmented LLM, the five workflow patterns (chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer), and the autonomous agent loop β with when to use each.
See the loopsGoogle Agent Design Patterns
Google Cloud's taxonomy organized by who decides the route: predetermined (sequential, parallel, loop) vs dynamic (coordinator, hierarchical, swarm), plus human-in-the-loop β and how to choose.
Compare patternsGetting Started with Loops
Designing agents that repeat cycles of work until a stop condition: the anatomy (trigger Β· stop Β· primitive), the four loop types (turn / goal / time / proactive), a worked example, and best practices.
Engineer loopsHarness vs Loop vs Graph
Three mindsets for building agents on the control-vs-autonomy spectrum: explicit graphs (you draw the flow), agentic loops (you set the cycle), and model-driven harnesses (the model drives) β trade-offs and how they compose.
Compare mindsetsREST vs GraphQL vs gRPC
Three ways for services to talk: REST's resources over HTTP, GraphQL's ask-for-exactly-what-you-need queries, and gRPC's fast typed binary RPC β the problem each solves, and when to choose which.
Compare API stylesGraphQL Deep-Dive
One typed endpoint, client-specified queries: the schema & type system, resolvers, the N+1 problem & DataLoader, cursor pagination, caching, the security guardrails a public API needs, and federation.
Query the graphNext.js Best Practices
The App Router done right: Server vs Client Components, data fetching & the four caching layers, rendering strategies (static, dynamic, streaming), Server Actions, performance, and the pitfalls to avoid.
Build with the grainAPIs vs MCP
How agents connect to tools: the MΓN integration problem MCP solves, how it works (hosts, clients, servers, tools/resources/prompts), a direct API-vs-MCP comparison, and when to use which.
Wire it upBuild MCP From Scratch
The hands-on companion: build an MCP server (the app that exposes tools/resources/prompts) and an MCP client/task that consumes them β with runnable examples, when-to-use scenarios, and how to run & connect them.
Build itWebMCP & A2A
Two emerging protocols: WebMCP brings MCP-style tools into the browser, and A2A lets agents discover and delegate to each other β how they differ from MCP and fit together.
Look aheadWeb Β· API Β· AI Security
A defensive guideline across the whole surface: HTTP/TLS, authentication & authorization, OWASP web & API risks, AI/agent threats (prompt injection, excessive agency), and a risk program β breach, user & automation.
Harden itOWASP β Top 10 & Toolbox
The de-facto language of app security: what OWASP is, the three Top 10 lists (Web, API, LLM) detailed, and the wider toolbox β ASVS, WSTG, Cheat Sheets, ZAP, Dependency-Check, SAMM & Juice Shop β across the SDLC.
Explore OWASPCyber Security
The big picture: the CIA triad, security mechanisms & controls, the threat landscape and cyber kill chain, how to prevent attacks (defense in depth, zero trust, MFA), and how to manage a program (NIST CSF, risk, incident response).
Defend & managen8n β Workflow Automation
Automate the glue between apps: what problem node-based workflows solve, how they work, n8n's limitations (fair-code licence, self-hosting, scale), and how it compares to Zapier, Make, Node-RED and more.
Automate itCloud Native
Building apps to fully exploit the cloud: containers, microservices, Kubernetes orchestration, CI/CD and observability β the pillars, the benefits, the real complexity cost, and when (not) to adopt it.
Go cloud nativeConcurrency Design
Balance security, idempotency, latency & capacity: architecture options and trade-offs, sizing with Little's Law, load-testing to the knee, retries for isolated failures, and AI-agent context isolation.
Design for scalePostgreSQL Query Performance
Stop guessing why a query is slow: how the planner works, reading EXPLAIN ANALYZE, indexes & statistics, the common anti-patterns and their fixes, and a worked 4.2 s β 0.3 ms optimisation.
PostgreSQL VACUUM
Why MVCC leaves dead tuples behind, what VACUUM actually reclaims, VACUUM vs VACUUM FULL, tuning autovacuum, transaction-ID wraparound & freezing, and detecting bloat β with a worked queue-table cleanup.
PostgreSQL Indexing Strategies
Match the index to the query: how a B-tree works, the six index types and when to use each, multicolumn column order, covering & partial & expression indexes, building safely with CONCURRENTLY, and auditing what to drop.
Sharding & Partitioning
Scale data past one machine: partitioning vs sharding, partition strategies (range/list/hash), choosing a shard key, sharding strategies, cross-shard joins & transactions, consistent hashing, and the ladder to climb before you shard.
Scale the dataAWS Services Field Guide
An architect's tour of 40 core AWS services across 9 categories β the problem each one solves, its real limits and quotas, and when to reach for it. Plus a look-alikes cheat sheet.
Explore servicesGCP Services & Infrastructure as Code
A field guide to Google Cloud β the resource hierarchy, core services by category (Cloud Run, BigQuery, Cloud SQL, Pub/Subβ¦), a GCPβAWS map β then an intro to Infrastructure as Code with a Terraform-on-GCP walkthrough.
Provision in codeTerraform vs Pulumi vs OpenTofu
Which IaC tool to build on: the model all three share, what each is, the 2023 licence change that forked OpenTofu from Terraform, the same stack written three ways, and a decision guide.
Compare IaC toolsIoT Γ Agents: a self-restocking fridge
Wire AWS IoT Core to a Strands agent on Bedrock AgentCore: a fridge detects low milk and auto-orders groceries β with architecture, five tabbed source files, and the guardrails auto-purchasing needs.
See it workNo tutorials match ββ.
Suggested reading order
New here? They build on each other β foundations first, then the systems and protocols that tie them together.
-
Building LLM Applications
Start with the fundamentals β chains, RAG, stateful agents, and tracing. Everything else assumes this vocabulary.
-
How LLMs & Transformers Work
Look under the hood β tokens, embeddings, attention and sampling β so the rest stops being a black box.
-
Prompt & Context Engineering
The highest-leverage skill β steer the model with instructions, examples and the right context before reaching for anything heavier.
-
How Embedding Models Work
Understand the vectors under the hood β what retrieval and semantic search are actually built on.
-
TensorFlow
The framework layer beneath the models β Google's platform, strongest on deployment reach.
-
PyTorch
The other giant β dynamic, pythonic, and dominant in research and the LLM ecosystem.
-
Knowledge Distillation
Shrink the model without losing its mind β train a small student to match a large teacher's whole output distribution, not just the labels.
-
Quantization & Pruning
Compress the weights themselves β fewer bits each (quantization) and fewer of them (pruning) β the other two levers that pair with distillation.
-
Lab: Train a Licence Recognizer
Put it into practice β a full from-scratch computer-vision lab: label, train weights, detect, OCR, serve.
-
How YOLO & Label Studio Work
Open up the two tools the lab uses β YOLO's detection architecture and Label Studio's labeling model.
-
RAG vs CAG vs GraphRAG
Go deep on grounding β how to get your data into the model reliably, and which retrieval method fits which corpus and question.
-
Fine-tuning vs RAG vs Prompting
Zoom out on the levers β when to prompt, when to retrieve, when to fine-tune, and how they stack together.
-
Vector Databases Compared
Where the vectors are stored and searched β from a one-line library to a distributed cluster.
-
LangChain vs LlamaIndex
Pick the framework to build on β orchestration-first (LangChain) or data/RAG-first (LlamaIndex), and when to combine them.
-
LLM Evaluation & Observability
Before you scale up to agents β learn to measure and monitor quality, so every later change is provable, not a guess.
-
Agent Development Kits
Now zoom out: how the frameworks for building agents differ, and how to pick one for the job.
-
AutoGen vs CrewAI
Two multi-agent frameworks head-to-head β conversation-first vs role-and-task-first, and which shape fits your work.
-
Anthropic Agent Architectures
The architectural vocabulary β workflows vs agents, the five patterns, and the agent loop.
-
Google Agent Design Patterns
The complementary taxonomy β predetermined vs dynamic routing, and the multi-agent topologies.
-
Getting Started with Loops
Put agents to work unattended β trigger, verify, stop β with the four loop types and their guardrails.
-
Harness vs Loop vs Graph
Step back β the three engineering mindsets for agents and when to impose structure vs trust the model.
-
Agent Topologies
Wire the agents together β the five shapes multi-agent systems take, their trade-offs, and how to grow the topology to fit the problem.
-
REST vs GraphQL vs gRPC
How services actually talk over the network β the API-design choices beneath every app and agent.
-
GraphQL Deep-Dive
Go deep on one API style β schema, resolvers, the N+1 fix, pagination, caching, and the guardrails a public graph needs.
-
Next.js Best Practices
Build the frontend that consumes it β Server Components, caching layers, Server Actions, and rendering strategies.
-
APIs vs MCP
How those agents reach the outside world β and why MCP standardizes connecting them to tools.
-
Build MCP From Scratch
Get hands-on β build an MCP server (app) and an MCP client (task), with examples and scenarios.
-
WebMCP & A2A
Where it's heading: tools in the browser, and agents that discover and delegate to each other.
-
Web Β· API Β· AI Security
Secure everything you've built β transport, identity, web/API risks, and the new AI/agent attack surface.
-
OWASP β Top 10 & Toolbox
The shared vocabulary of app security β the Top 10 risk lists and the standards/tools that operationalize them.
-
Cyber Security
Zoom out to the whole program β mechanisms, attack prevention, and how to govern & manage security.
-
n8n β Workflow Automation
Zoom out to the practical: wire apps and APIs into automated workflows β low-code, self-hosted, with code when you need it.
-
Cloud Native
The architectural approach beneath modern cloud apps β containers, microservices and orchestration, vendor-neutral.
-
Concurrency Design
Make it handle load safely β capacity, resilience, failure isolation, and per-run agent isolation.
-
PostgreSQL Query Performance
Make the database keep up β read the query plan, add the right indexes, and fix the slow statements underneath it all.
-
PostgreSQL VACUUM
Keep the database from bloating β reclaim dead tuples, tune autovacuum, and stay clear of transaction-ID wraparound.
-
PostgreSQL Indexing Strategies
Make reads fast without over-taxing writes β pick the right index type, column order, and partial/covering shape for each query.
-
AWS Services Field Guide
Learn the cloud building blocks β compute, storage, messaging, Bedrock β that agents and apps actually run on.
-
GCP Services & Infrastructure as Code
The other major cloud β plus how to provision any of it in code with Terraform, not console clicks.
-
Terraform vs Pulumi vs OpenTofu
Pick the IaC tool itself β the shared model, the licence fork behind OpenTofu, and Terraform vs Pulumi's real-language approach.
-
IoT Γ Agents
Put it all together in one end-to-end system: a device event triggers an agent that reasons and acts in the real world.