AI &amp; Systems Engineering Knowledge Graph

Senior Product Manager →

Lead an AI feature end to end: the approach, the quality bar, the cost and the risk.

AI Product Lead →

Own grounding, context, memory, agents, trust and cost across an AI product line.

AI Engineer →

Build, test and run a retrieval-backed, tool-using agent, and explain how it fails.

AI Engineering Lead →

Review architecture, set quality and safety standards, and control cost.

Learn by seeing

New

Visual explainers →

Follow one example through a system or a product decision, one stage at a time, with a picture at every stage. How AI systems work: an LLM request, how a model learns, a token through a transformer, an image model, an agent run and a guardrailed request. How AI products are run: a launch, a model change, a margin, an eval regression, an agent spec and an incident.

All modules

AI engineering →

The engineering discipline under production LLM systems — inference, retrieval, evals, observability, safety, cost. Designed reading editions.

Harness engineering →

Build a coding agent's harness from scratch — loop, tools, context, permissions, subagents — then use the real SDK. 10 phases, 41 lessons, one tested capstone.

Flowable →

Process automation from scratch — build a token engine, wait states, and a job executor by hand, then run real BPMN on the Flowable engine. Concept-first for PMs, with a build layer for engineers.

First principles →

Reason from fundamentals and build range across disciplines — the method, a latticework of mental models, becoming a polymath, and learning how to learn.

Product sense →

The instinct for what makes a product succeed, for APMs & PMs moving into AI PM — motivation, empathy, creativity, communication, domain expertise, and product sense for AI.

Technical product sense →

Read systems like an engineer — architecture, APIs, data, latency, reliability, and tech debt — with a diagram in every lesson. For APMs & PMs moving into AI PM.

Technical product management →

The operating discipline of shipping — the role, specs, prioritization, execution, metrics, and releases — with a diagram in every lesson. For APMs & PMs moving into AI PM.

Agentic AI →

What agents actually are — the loop, tools, memory, planning — plus reliability, security, and economics. Opens with a knowledge graph; a diagram in every lesson.

Knowledge graphs →

Treat what the company knows as a product — entities and ontologies, the construction pipeline, GraphRAG, governance, and the business case, in product leader language.

Machine learning →

What a learned system is, what it learns from, how it learns, how to trust its score, which model family to pick, and how to keep it working after launch. Runnable code in every lesson.

Tensors →

What the objects every model works on are, what they cost in memory and compute, why shape errors are silent, and how a library gets the gradient for free. Runnable code in every lesson.

Convolutional networks →

How a vision model sees, what resolution and depth cost, when to reuse a pre-trained or foundation model, and why vision features break in production. Runnable code in three lessons.

Transformers →

The stack behind almost every language model: attention, the block, position and the cost of context, the KV cache, and reading a model card as memory, compute and cost. Runnable code in every lesson.

Craft

Building AI-native products →

Five skills for the AI product leader: opinionated UX for ambiguous interaction, model intuition, pixels to evals to hill climbing, agentic flows and how users behave with agents. Templates and teardowns in every practice lesson.

Craft

AI-assisted development for leaders →

What changes when a coding agent writes the code: specifying, verifying, controlling and measuring the work. Runnable code in every lesson, including a real Stop-hook script.

Fine-tuning and post-training →

How a base model becomes an assistant, what supervised tuning, LoRA and preference tuning change, why the dataset is the product, and how to test the break-even and gate the release. Runnable code in every lesson.

Generative AI: the big picture →

What makes AI "generative," the five modalities, why output is probabilistic, the four-layer product stack, and build vs. buy vs. fine-tune. Opens the Generative AI family.

LLMs →

Tokens, the context window, the jagged frontier, prompting, sampling, choosing a model, and the order to reach for prompting, RAG, or fine-tuning.

APIs & integrations →

The request/response contract, authentication, rate limits, streaming, retries, structured output, webhooks, and fitting a model call into a real system.

RAG & vector databases →

Grounding models in your data — when to use RAG and when not to, embeddings, vector databases, chunking, retrieval quality, and a hands-on build with Claude Code and pgvector.

Memory & context →

Memory as a product decision, the three shapes it takes, how memories are written and kept, the designs for reading them back, and the trust failures it has to be designed against.

Tool calling →

The line where an AI product stops talking and starts doing: designing a tool worth trusting, and keeping the permission boundary around it real.

AI agents →

The loop behind every agent, how much autonomy a task needs, what keeps it reliable across many steps, when not to build one, how to run one safely, and how to choose one.

Agentic workflows →

Choosing a workflow pattern, when more than one agent earns its cost, and what it takes to make a workflow durable enough to own end to end.

Evaluation & observability →

Why the eval set is the product spec for a non-deterministic system, and the order to actually build the eval and observability stack in.

AI security & guardrails →

Jailbreak, injection, extraction, and poisoning are four different attacks. How to test your defenses, and how governance becomes compliance evidence a regulator or buyer can check.

Cost optimization →

Which lever fixes which cost driver, the build-vs-buy breakeven done as arithmetic, and the FinOps practice that turns attribution into governance before the invoice, not after.

System design →

How real systems are designed at scale — from rate limiters to stock exchanges — with the architecture, tradeoffs, and failure modes that shape product decisions. 28 systems plus lessons on distributed data, caching, ML and GenAI systems, social media and reliability, a question bank and runnable code, diagrams included.