Course Description
Large language models (LLMs) have transformed software development from a purely hands-on coding process into one carried out alongside increasingly capable coding agents. This shift requires rethinking how intent is defined, how work is structured, and how tools are coordinated so that agents can contribute effectively to complex software projects.
This course covers the current practices and technologies behind AI-native software development, including MCP (Model Context Protocol), agent skills, spec-driven development, context engineering, and the software factory. Students will learn how to provide agents with the right context and capabilities, how to translate product requirements into executable specifications, and how to design iterative workflows in which humans and agents jointly plan, build, evaluate, and improve software.
Through hands-on assignments, a group project, and weekly sessions, students will explore both the capabilities and the limitations of today's coding agents. By the end of the course, students will be able to design effective agent-driven workflows, turn tools and skills into reliable development systems, and apply software-factory principles to build software faster and at greater scale.
Course Details
Tools and Platforms Used
The agentic development ecosystem used throughout the course:
- Antigravity — main development/experimentation environment
- Google ADK (Agent Development Kit) — for agent integrations
- 5 students per project group, working from a shared Google Cloud workspace
Antigravity
Google Cloud
Gemini API
Google ADK
Classroom Management
Each week opens with a recap of that week's agenda, deadlines, and group progress. Attendance and participation are taken at the start of class; the last 10–15 minutes of each session are reserved for questions and discussion.
Instructors
SD
INSTRUCTOR
Scott Davis
University of California, Santa Cruz
SC
INSTRUCTOR
Sedanur Ceylan
Founder, Dream Data Labs
MD
INSTRUCTOR
Dr. Muhammed Davud
Istinye University
Weekly Schedule
WEEK 1
Introduction and Course Logistics
−
- Introduction to Large Language Models
- Forming project groups of 5
- Introduction to the tools we'll use: Antigravity, Google ADK setup
- Course logistics: attendance, participation, and grading breakdown explained (5% attendance, 5% participation, the rest split evenly across Test 1 / Test 2 / Project)
- Remaining time: What are the foundations of modern software? — an introductory discussion on the languages, tools, and paradigms shaping software development today
WEEK 2
Software Development Life Cycle (SDLC)
+
- Classic SDLC models: waterfall, agile, spiral
- How SDLC is changing in modern, AI-assisted development
- The Plan → Build → Change → Repeat loop, and an introduction to agent-assisted workflows
WEEK 3
Requirements, Architecture, and Agentic Systems
+
- Deriving requirements specifications and a roadmap
- Fundamentals of software design and architecture
- Introduction to agentic systems: what an agent is, and how it differs from traditional software
WEEK 4
The Internals of Coding Agents
+
- The components of a coding agent: planning, tool use, memory
- The decision loop of LLM-based agents (reasoning-act-observe)
- A look at popular coding agent architectures
WEEK 5
Advanced Context Engineering
+
- Advanced prompting techniques and when each applies
- RePPIT (Research, Propose, Plan, Implement, Test) and spec-driven development
- MCP fundamentals: servers, clients, tools, and transport
- Designing tools for agent ergonomics
WEEK 6
Agent Skills, Rules, and Guardrails
+
- Agent skills: giving agents reusable capabilities
- Constraining agent behavior with rules
- Designing reliable workflows by composing skills and rules
WEEK 7
Agentic Code Review and Testing
+
- Approaches for reviewing code written by agents
- Automated static analysis and agent-assisted code review tools
- Testing strategies for agent-generated code
- Designing code review processes for human-agent collaboration
WEEK 8
Deployment and Monitoring Agentic Applications
+
- Strategies for taking agentic applications to production
- Fundamentals of monitoring, logging, and observability
- Tracking agent behavior in live environments
WEEK 9
Agent Security and Quality
+
- Agent security: prompt injection, data leakage, unauthorized access risks
- Safe "vibe coding" practices
WEEK 10
The Software Factory
+
- The software factory concept: treating software as a scalable, repeatable production process
- Production lines where agentic systems are only monitored, with minimal human intervention
- Reliability at scale: metrics, feedback loops, quality gates
WEEK 11
Project Presentations
+
- Each group presents the agentic software project they built over the term
- Evaluating architectural decisions, the skill/rule sets used, and the security measures in place
- Peer evaluation and final feedback
Project Teams
Students are placed into groups of 5 at the start of the term and work together on an agentic software project throughout the course. The project is built in Antigravity, using Google ADK integrations. Each group advances its project in step with the weekly topics (SDLC, requirements analysis, architecture, context engineering, agent skills, code review, deployment, security) and presents it to the class in Week 11.
Grading
| Attendance | 5% |
| Participation | 5% |
| Test 1 | 30% |
| Test 2 | 30% |
| Term Project | 30% |
Frequently Asked Questions
Do I need prior AI/ML experience?
No. You just need programming experience. Everything specific to agentic systems is taught from the ground up starting in Week 4.
How are project groups formed, and can I choose my teammates?
Groups of 5 are formed in Week 1. Each group works on the same agentic software project throughout the term and presents it to the class in Week 11. Group formation is coordinated during the first session — talk to the instructors that week if you have a preference.
What if I don't have access to Antigravity?
You'll need a personal Google account to use Antigravity — accounts are not provided by the course, so each student creates and uses their own. Setup details are shared in Week 1 when project groups are formed.
Is there a cost associated with the tools used in this course?
Access to Antigravity and the shared Google Cloud workspace is provided through the course. If your project scales beyond the included usage, this will be discussed with your group directly.
What does the Week 11 presentation need to include?
A working demo of your agentic software project, plus a walkthrough of your architecture decisions, the skills/rules you designed, and the security measures you put in place.
What's the attendance and participation policy?
Attendance and participation are each worth 5% of your grade and are recorded at the start of every session.
Who do I contact with questions outside of class?
You can reach us via email.
📚 CURRICULUM RESOURCES • WEEK 3 / ANATOMY OF CODING AGENTS
Papers to Read — Anatomy of Coding Agents
This week traces the technical lineage behind contemporary coding agents: the Transformer architecture; pretrained language representations; preference learning and reinforcement learning; and reasoning-oriented models. The goal is not to memorize every objective function, but to develop a working mental model of why a coding agent can interpret context, generate code, use tools, revise a plan, and still fail in systematic ways.
Start Here — Coding-Agent Companion Resources
Stanford CS146S
Also used in CS146S: The Modern Software Developer, Stanford University, Fall 2026 as Week 1 reading for The Internals of Coding Agents. Strongly encouraged before class.
Video Walkthrough
Building a Coding Agent
A deep-dive video walkthrough of the internal systems, state machines, and execution loops behind a coding agent.
Watch Video →
Practitioner Lessons
Lessons from Building Claude Code
First-hand engineering lessons, ergonomics, and architectural pitfalls learned while developing an agentic coding product.
Read Post on X →
Technical Paper
Dive into Claude Code
Comprehensive analysis paper on the architectural design, tool execution, and runtime operation of Claude Code.
Read arXiv PDF →
Visual Mental Model
Visual representation of coding agents and their limitations
A visual model of agent loops, tool use, context window limits, and systematic failure modes.
Watch Video →
Mandatory Pre-Class Reading & Viewing
Required
Mandatory Paper 1
Attention Is All You Need
Why it matters: This paper introduced the Transformer architecture: self-attention, multi-head attention, positional information, and parallel sequence processing. Modern LLMs—and therefore coding agents—are built on this lineage. It explains how a model can relate a token in a current edit to relevant tokens elsewhere in a prompt or codebase context.
• Required reading: Abstract, introduction, model architecture, and conclusion. Understand what self-attention buys compared with recurrence.
Mandatory Viewing 2
Visual representation of coding agents and their limitations
Why it matters: The Transformer explains the model inside the agent; this video focuses on the surrounding system: context gathering, planning, tool calls, feedback loops, and where those loops break down. Pair it with the attention paper to distinguish a language model from an agentic software developer.
• Required viewing: Watch before class and bring one example of a limitation that is primarily a system/agent-loop problem rather than a base-model knowledge problem.
💡 Questions to Bring to Class
- In a coding-agent prompt containing an issue, repository files, terminal output, and tests, what could attention help the model relate—and what does it not guarantee?
- Which parts of a coding agent are learned model behavior, and which are ordinary software engineering around the model?
- Why can an agent with a strong model still make a bad patch after apparently reading the relevant code?
Reference Papers — Chronological Foundational Sequence
2017 – 2025
Ordered chronologically to trace the evolution: architecture → preference learning → pretraining → code specialization → reasoning/tool loops → preference optimization → reasoning-model RL.
Ashish Vaswani et al. • NeurIPS 2017
The foundational Transformer paper. Its self-attention mechanism is the architectural basis for all modern LLMs used by coding agents today.
Paul Christiano, Jan Leike, Tom B. Brown, Dario Amodei, et al.
The conceptual precursor to RLHF: learn a reward model from human comparison choices rather than requiring a hand-written reward function.
Jacob Devlin, Ming-Wei Chang, Kenton Lee, Kristina Toutanova
Established the paradigm of large-scale Transformer pretraining followed by task-specific adaptation, transforming NLP and developer tooling.
Tom B. Brown et al. (OpenAI)
Demonstrated that sufficiently scaled autoregressive models can perform new tasks directly from in-context prompt instructions without weight updates.
Mark Chen et al. (OpenAI)
Introduces Codex and the HumanEval benchmark. Focused the field on evaluating functional correctness rather than mere surface plausibility.
Jason Wei et al. (Google Research)
Shows that prompting intermediate scratchpad steps dramatically unlocks multi-step problem solving. Foundational for agent planning and task decomposition.
Long Ouyang et al. (OpenAI)
The landmark account of the SFT → reward model → PPO policy optimization pipeline that turned raw text predictors into reliable assistants.
Shunyu Yao et al. (Princeton & Google)
Establishes the core agent loop: interleave reasoning traces with tool actions and environment observations. Direct ancestor of coding agent terminal loops.
Rafael Rafailov, Chelsea Finn, Christopher D. Manning, et al. (Stanford)
Reformulates preference alignment directly from preference pairs without training a separate reward model or complex online RL policy loops.
Zhihong Shao et al. (DeepSeek-AI)
Introduces Group Relative Policy Optimization (GRPO), eliminating the memory-heavy critic network in RL for reasoning models.
OpenAI Research (2024)
The public debut of test-time reasoning models. Frames reinforcement learning and test-time token allocation as keys to solving complex STEM and coding problems.
DeepSeek-AI et al. (2025)
Documents the open DeepSeek-R1/R1-Zero reasoning training approach: pure-RL experiments followed by multi-stage fine-tuning for extended self-verification behaviors.
How to Read These Papers — 4 Evaluation Questions
Analytical Framework
01 / CAPABILITY
What capability is being added?
Long-range token interaction, pretrained representations, preference adherence, or test-time reasoning computation.
02 / SIGNAL
What is the training signal?
Next-token self-supervision, ground-truth labels, human preference comparisons, or verifiable rule-based rewards.
03 / TRADEOFF
What is the engineering trade-off?
Compute budget, memory overhead, dataset curation difficulty, controllability, runtime latency, or verification cost.
04 / AGENTS
What does this imply for agents?
Better token prediction does not itself provide repo context, correct tool execution, or accountable engineering judgment.
Core Course Takeaway
“A coding agent is a system, not a single model: a Transformer-based language model is trained and aligned using particular objectives, then embedded in a loop that selects context, proposes actions, invokes tools, observes results, and tries again. Each layer introduces capability—and its own failure modes.”