Lectures

Part 1: Foundations of Coding Agents

Lecture: Course Introduction + How LLMs Actually Work

This lecture introduces agentic software engineering and explains the LLM machinery beneath coding agents: tokenization, next-token prediction, transformer basics, model training, context windows, and statelessness. Understanding these foundations clarifies how agents can produce code, but also why agent output can be nondeterministic or confidently wrong—and why deliberate context management and verification are essential throughout the course.

  • Lecture Notes (md)
  • Readings/Videos to cover before next lecture
    • [required] Karpathy, Intro to Large Language Models (YouTube, ~1 h) — the designated gap-filler
    • [recommended] 3Blue1Brown, But what is a GPT? and Attention in Transformers (YouTube) — additional shorter material with good visuals
    • [optional deeper dive into how LLMs work] Karpathy, Deep Dive into LLMs like ChatGPT; Vaswani et al., Attention Is All You Need (skim §1–2); Ouyang et al. 2022 (InstructGPT) for RLHF.

Lecture: From LLM to Agent: The Loop, System Prompts, and Tool Calls

This lecture explains the concept of a agent “harness” - software that wraps an LLM (model) and turns it into an agent by maintaining message history, defining tools, executing tool requests, and repeating the model–tool loop. This model-versus-harness distinction helps students reason clearly about agent capabilities, safety boundaries, and failure modes throughout the course.

  • Lecture Notes (md)
  • Readings/Videos to cover before next lecture
    • [required] The Carbon Layer - YouTube Channel - Harness Engineering Masterclass: Technical Deep Dive on how to build Agentic Systems — up to timestamp 14:00 is good enough for preparing for L03. This is a Week 1-3 core reference (our toy agent will address the first several “primitives” (building blocks) for a coding agent that are introduced in the video.
    • [optional – see how Claude handles tool calls] Anthropic API docs, Tool use overview (skim to recognize the basic ideas)
    • [recommended] Yao et al., ReAct (skim §1–3).
  • Exercise: Ex. 1 — transcript critique (md), due before Lecture 04.

Lecture: Claude Code Hands-On: Permissions, CLAUDE.md, and Plan Mode

This lecture describe how what one sees in Claude Code’s “industrial strength” interface relates to the concepts in the “toy agent” harness and loop actions presented in the previous lecture. It describes the basic information and commands that a developer provides to the agent to control the production of code: permissions, project instructions, explicit context, reusable commands, and plan mode. This introduction establishes the habits developers need to work with coding agents deliberately and safely. It also provides a first understanding of how developers control the information that feeds into the model context, i.e., exactly what content is being supplied as input to the LLM to get it to produce code.

  • Lecture Notes (md)
  • Readings/Videos to cover before next lecture

Lecture: Prompting + Spec-Driven Development

Lecture 4 uses contrasting development attempts to show how precise requirements, durable specifications, existing patterns, and built-in verification matter more than clever prompts. The concept of Spec (Specification)-driven development is introduced: organizing the development process are declarative specifications of what should be built, the desired behavior of the system, and how the system should be verified (rather than focusing on the details of coding and how system behavior is implemented). Spec-driven development is central to the agentic development because it expresses the developer’s intentions in human-reviewable documents while also directing agents with a stable source of truth as projects grow.

  • Lecture Notes (md)

Lecture: Anatomy of a Coding Agent: Building the Toy Agent

Lecture 5 assembles the course concepts into a working coding agent built with a model API, system prompt, message history, tool definitions, and a guarded dispatch loop. The lecture starts with an overview of how a chatbot works, and explains what features need to be added to turn a chatbot into a coding agent. Building this small agent demystifies production coding tools like Claude Code and makes their key reliability and safety mechanisms concrete enough to inspect, test, and improve.

  • Lecture Notes (md)

Lecture: Context, Cost, Verification, and the Road Ahead

Lecture 6 examines the cost and quality consequences of growing context, practical strategies for managing sessions, and the verification gates needed to catch plausible but incorrect output. It brings the foundations unit together around the course’s larger goal: producing trustworthy software with agents as project scale and autonomy increase.

  • Lecture Notes (md)

Part 2: Agentic Software Engineering Principles

Lecture material to be announced - the content addresses the following

  • survey core software engineering concepts and how those concepts are re-oriented when working with coding agents,
  • central features and usage modes of coding agents – you’ll learn how to confidently apply agents on your own to small and medium-sized projects
  • we’ll work on a first project, building it and evolving it in several ways with agents to understand the basics of agentic software engineering

Part 3: Agentic Development at Scale

Lecture material to be announced.