Part 1: Foundations

Start from zero. Build the vocabulary and mental models everything else depends on.

• Module 1: What AI actually is, minus the hype: AI vs ML vs deep learning. Models, parameters, weights, training vs inference. Supervised, unsupervised, reinforcement learning. Where AI is already running inside your company, whether you approved it or not.
• Module 2: Neural networks and transformers: Neurons and layers for engineers, not mathematicians. Why transformers replaced everything before them. Attention, explained so it clicks. Training vs running a model, and why the cost profiles differ wildly.
• Module 3: Inside a large language model: Tokenization, and why it explains half the weird behavior you have seen. Embeddings. Context windows and the constraints they put on your design. Temperature and sampling: the dials you will actually turn. Why models hallucinate, and what that means for what you are allowed to build.

By the end of Part 1 you can read any AI claim, vendor pitch, or job posting and know exactly what is being said, and predict where a model will fail before you write code.

Part 2: Building with LLMs

Go from understanding models to building things with them that hold up under real use.

• Module 4: Prompt engineering that survives contact with users: Zero-shot vs few-shot. System vs user prompts, and who controls what. Structured outputs your code can trust. Chain of thought. Common failure patterns. Prompt injection: your first look at the attack surface.
• Module 5: Embeddings and vector search: What an embedding represents. Similarity search. Choosing a vector database without regret. Chunking strategies, which is where most real systems quietly go wrong.
• Module 6: Retrieval augmented generation (RAG): The most requested AI capability in the enterprise today. The architecture end to end. RAG vs fine-tuning, and making that call correctly the first time. Evaluating retrieval quality, because “it seems better” is not an answer. The pitfalls that sink most first builds.
• Module 7: Function calling and tool use: The hinge the rest of the course turns on. How function calling works. Designing tool schemas a model will use correctly. Handling errors, retries, and partial failure.

By the end of Part 2 you have built a grounded RAG system over real data and connected a model to working APIs.

Part 3: Agents and MCP

How models plan, take multi-step actions, and connect to real systems.

• Module 8: AI agents: The agent loop. The ReAct pattern. Planning and reflection. Where agents fail in production, drawn from real failures rather than demos. How to avoid betting on the wrong framework.
• Module 9: Model Context Protocol (MCP): The piece almost nobody has hands-on experience with yet, which is exactly why it is worth having. What problem MCP solves. Client and server architecture. Tools, resources, and prompts. Connecting to a live MCP server, then building your own. Security considerations, which are not optional.
• Module 10: Multi-agent systems: Single agent vs multi-agent, including the honest case for staying with one. Sharing context and state. Orchestration patterns. Guardrails against runaway loops and runaway bills.

By the end of Part 3 you have built and connected an MCP server and designed an agent for a real task, including where it needs a human.

Part 4: Production and the Enterprise

Take it from prototype to something you would put your name on.

1. Module 11: Fine-tuning and model customization: Fine-tuning vs RAG vs prompting: the decision framework. Full fine-tuning vs parameter-efficient methods. Data preparation. The cost and maintenance trade-offs nobody mentions in the blog posts.
2. Module 12: Running AI inside your own walls: The fastest-growing enterprise requirement in AI, and one very few engineers can meet. Why enterprises are pulling AI back inside the perimeter. Hosted vs self-hosted and open-weight models. Deploying with no route to the public internet. Keeping data, embeddings, and vector stores inside the boundary. What you give up, what you gain, and how to have that conversation with a client.
3. Module 13: LLMOps and production readiness: Building an evaluation harness, and why you build it before the feature. Monitoring model behavior over time. Versioning prompts as the artifacts they are. Controlling inference cost before finance does it for you.
4. Module 14: AI security and responsible AI: Prompt injection and jailbreaks from the defender's side. Data leakage and privacy risk. Guardrails and human-in-the-loop review. Bias, fairness, and setting expectations you can meet.
5. Module 15: Capstone: Design the assistant. Build it against a real task. Present the architecture to the group. Demo, review, and critique. You leave with the system, the code, and the reasoning behind both.

By the end of Part 4 you can take an AI system from idea to production. You know how to deploy it, secure it, monitor it, control its cost, and defend your architectural decisions to engineering leaders, security teams, and clients. You are no longer experimenting with AI. You are operating it.

Engineers, architects, and technical leads whose stack has nothing to do with AI yet, and who know that is a problem. Equally, the ones already using AI daily, shipping features against an API, who can feel how much is happening underneath that they never had time to learn. Ops and platform people who saw the DevOps shift and want to be early this time. Consultants and solution engineers who need to be credible in a client environment on day one.

Prerequisites: working knowledge of one programming language. Nothing else.

• A working capstone system you built, and a firm enough grasp of how the pieces fit together to walk anyone through it
• The ability to build retrieval over your own company's data instead of guessing what the model knows
• Models wired to your real APIs, taking real actions, with error handling that holds up
• Hands-on experience with MCP, the standard the industry is converging on for connecting models to systems
• A method for taking a legacy workflow apart and redesigning it around agents, and the judgment to know when not to
• The ability to deploy AI inside an enterprise boundary where data is not permitted to leave
• Evaluation, monitoring, and cost control good enough to survive a production review