An introduction to artificial intelligence that starts with the basic idea of what AI is.
Back to portfolioAI & systems, made clear.
LEARNING & CONTENT CREATION
AI & systems, made clear.
One idea at a time.
Visual lessons on generative AI, agentic systems and system design. Start with the fundamentals, explore a topic, or follow a series from the first lesson.
Follow the daily breakdowns on LinkedInChoose a learning path
Foundations first. Deeper systems next.The collection
85 modules across 3 seriesGenAI
30 modulesIntroduces generative AI and its ability to create content such as images, music and text.
Explains how a generator and discriminator compete to produce realistic generated content.
Introduces transformers and diffusion models as foundations for modern text and image generation.
Introduces ethical AI and the responsibility that comes with using generative technology.
Introduces prompt engineering as a way to communicate requests and guide AI outputs.
Moves from AI theory to approachable projects that learners can build themselves.
Introduces large language models and their role in systems such as ChatGPT.
Introduces Midjourney as a tool for creating AI-generated images.
Presents tips, workflows and the plugin concepts covered in this ChatGPT learning module.
Explore how generative AI supports everyday work, creative tasks and hobbies.
Introduce AI agents through a simple example of an assistant that acts on a request.
Explore an introductory overview of AI applications in healthcare.
Introduce retrieval-augmented generation and its role in grounding model responses in external information.
Explain how vector embeddings represent words and their meaning as numbers.
Compare fine-tuning and retrieval-augmented generation as approaches to customizing an AI system.
Introduce AI systems that work across text, images and audio.
Explore how generative AI can assist with writing, debugging and explaining code.
Introduce the offline indexing process that prepares documents for a RAG knowledge library.
Explore how a retrieval system searches a vector database for information relevant to a question.
Introduces how an LLM combines retrieved context into a final answer during the generation stage.
Explains why basic vector similarity can miss relevant information and motivates more precise retrieval for vague or multi-part questions.
Introduces objective measurement of RAG answer quality, contrasting evaluation metrics with informal impressions.
Connects the offline knowledge-indexing pipeline with the live retrieval-and-generation pipeline in a production RAG architecture.
Introduces AI agents as systems that move beyond answering questions to completing tasks.
Introduces the LLM core, tool kit and memory as the main components of an AI agent.
Introduces ReAct as a framework connecting step-by-step reasoning with actions in AI agents.
Introduces how adding tools expands the practical capabilities of a ReAct agent.
Introduces collaboration between specialized agents, including research, planning and communication roles.
Introduces a vision of agents as collaborators in personal administration, science and software, alongside the challenges ahead.
Agentic AI
25 modulesThe difference between using a tool and working toward a goal with decisions and feedback.
Compare conversational responses, predefined workflows and agents that choose their next action.
A visual introduction to the components that make an agent useful.
Follow an agent through decisions, actions and observations as it works toward a goal.
Consider when an agent helps and when a simpler approach fits the task.
Explore how tools connect an agent to actions outside the language model.
Explore ReAct, plan-and-execute and hybrid planning, with examples of replanning, progress tracking and stopping conditions.
Understand working and long-term memory, then follow how agents store, retrieve, correct and delete information.
Learn how to gather, select and structure context while preserving source authority and boundaries around untrusted content.
Compare fixed retrieval pipelines with query decomposition, source routing and iterative evidence gathering.
Design a focused agent with success criteria, useful tools, relevant context, working state and behavioral evaluation.
Explore specialist routing, handoffs, supervisors and parallel agents, including the costs of coordinating their work.
Explains how agents plan research, explore and compare sources, verify evidence, and synthesize a cited report.
Introduces reflection and evaluator-optimizer loops that use clear criteria, feedback, and verification to improve agent outputs.
Explains how long-running agents preserve state, save checkpoints, and resume safely through interruptions and human approvals.
Introduces MCP as a shared protocol for connecting AI applications to external tools and data through reusable clients and servers.
Introduces A2A as a shared protocol for independent agents to discover capabilities, delegate tasks, communicate, and return results.
Explains how A2UI lets agents describe interactive interfaces that host applications render using their own components.
Introduces AG-UI as the live communication layer for streaming agent events, synchronizing state, and exchanging tools and user input.
Explains how an agent harness combines tools, state, runtime controls and tracing to turn a model into an operating agent.
Introduces agent evaluations that use task contracts, repeated trials, traces and graders to measure outcomes, safety and cost.
Explains how short-term and long-term memory retain selected information and retrieve it into context for future work.
Shows when agents should plan, how to break goals into ordered actions, and when new evidence calls for replanning.
Introduces ReAct, reflection and search as control loops for choosing actions, checking results and improving decisions.
Examines prompt injection and tool-related risks, with trust boundaries, limited permissions, approvals and tracing to control agent actions.
System Design
30 modulesLearn how data, models, tools, and application logic work together to turn an AI model into a useful, reliable product.
Define the user’s job, system constraints, and measurable success criteria before writing a practical design brief for an AI policy assistant.
Compare rules, predictive models, retrieval workflows, and agents to choose an architecture that fits the required output and execution path.
Trace how data preparation and serving connect in a policy assistant and demand forecast, including artifacts, tool responsibilities, and quality measures.
Design API contracts that validate requests, establish identity, and enforce permissions before protected data reaches the model.
Turn AI requirements into realistic test cases, scoring rules, and explicit release criteria.
Define the customer population, prediction moment, observation window, and outcome that make a precise training example.
Create data contracts that check schemas, missing values, duplicates, and freshness, with clear responses when checks fail.
Design training and evaluation splits that respect time, entity boundaries, and the information available when predictions are made.
Define and version reproducible features so training and serving use consistent meanings, time windows, and available data.
Compare a learned model with a baseline and choose thresholds using precision, recall, error costs, and review capacity.
Connect retained data, experiment runs, fitted artifacts, and decision policies in an inspectable release manifest.
Design batch inference with pinned inputs, stable partitions, safe retries, complete validation, and atomic publication.
Design an online prediction service with valid features, bounded latency, capacity limits, and fallback behavior.
Choose feature infrastructure from reuse, historical retrieval, freshness, and operational ownership requirements.
Distinguish data drift from model quality changes and design alerts around delayed outcomes and label coverage.
Design recommendation retrieval and ranking, then evaluate relevance, availability, coverage, and latency at each stage.
Connect data, features, training, release, serving, and monitoring through explicit contracts and recovery paths.
Build and version a prompt contract with distinct instructions, request data, evidence, output rules, and evaluation cases.
Route structured model outputs through completion, refusal, schema, meaning, and authorization checks.
Compare model candidates on shared task cases using eligibility gates, quality, latency, cost, and uncertainty.
Diagnose model failures and choose prompting, retrieval, or fine-tuning with a testable baseline.
Design a context budget that preserves essential evidence, manages conversation history, and handles overflow deliberately.
Design streaming responses with clear completion states, separate latency measures, cancellation, and validation of finished output.
Build document ingestion that preserves source provenance, audits extraction quality, and tracks permissions and versions.
Choose chunk boundaries and metadata that preserve meaning, source references, permissions, and document versions.
Design a vector index with consistent embeddings, controlled version activation, reliable updates, and explicit deletion behavior.
Combine lexical and vector retrieval, rerank eligible evidence, and assemble context within separate candidate and token budgets.
Authorize evidence before generation, connect claims to supporting passages, and handle denied, missing, or conflicting sources.
Diagnose failures across the RAG pipeline and compare controlled changes using retrieval, answer quality, access, latency, and cost measures.