MPCS 51238 Design, Build, Ship (Spring 2026)

Overview

This is an agentic engineering course. You’ll learn to build and ship software by directing AI systems as structured collaborators—not as a novelty, but as a core discipline for the next era of software engineering. 

Weeks 1-4 focus on structured assignments that build foundational skills: using Claude Code, debugging, version control, hosting, frameworks, testing, deployments, and effective LLM collaboration. You'll learn the workflows that make AI-assisted development actually work—managing context, reading output, recovering from mistakes.

Weeks 5-10 shift to an individual project where you'll apply these skills to build and ship something real. Projects can be civic, creative, educational, experimental, or entrepreneurial. No prior design or AI experience required. The goal is to make something you're proud of and get it into the world.

This class welcomes students at varying skill levels.                                                                         

Learning Objectives

By the end of this course, students will be able to:

Build with LLMs

• Collaborate effectively with AI coding tools
• Manage context: what to include, when to start fresh, how to mold the models to do what you want
• Create feedback loops with LLMs with logs, testing, and MCP servers
• Debug with AI assistance: know when to trust it, when to question it
• Maintain control: git workflows, reviewing changes, recovering from mistakes

Create & Experiment

• Develop your own ideas worth building — civic, artistic, personal, experimental
• Embrace productive failure: launch early, learn fast, iterate
• Take creative risks knowing you can recover
• Recognize that imagination—not technology—is now the limiting factor
• Ship imperfect work to find out what actually matters

Design & Prototype

• Design interfaces directly in code using AI and component libraries
• Apply core UI/UX principles: visual hierarchy, layout, feedback, accessibility
• Iterate rapidly: describe what you want, evaluate the output, refine
• Use component libraries to guide design decisions

Develop & Ship

• Build full-stack applications using modern frameworks
• Integrate systems: authentication, databases, APIs
• Write and run tests to validate functionality
• Deploy to production: hosting, environments, builds
• Debug systematically: console logging, error tracking, reading stack traces
  

Course Structure

Weekly format:

Group Discussions

Each class opens with discussion on the larger themes surrounding AI and building: agency, creativity, imagination, craft, what it means to make things in this moment. Conceptual foundations for why this work matters and where it's heading. 

Workshops

Hands-on introductions to this week’s technical focus. During weeks 1 - 4, this covers foundational skills, during weeks 5 - 10, workshops shift to topics driven by what students need for their projects.

Build Time

Students work on assignments or projects with direct support from the instructor and TA. Blockers get addressed in real-time. This class emphasizes learning through doing.

Progress Share-Outs

Brief demos of progress. What did you try? What broke? What surprised you? Peer feedback is encouraged, as there is a lot to learn and collaborate on from the experience of others.

Participation

The expectation is that students will attend class each week. Due to the nature of this course, attendance is essential and required. Failure to attend class on a regular basis could result in a failing grade in the course. If the class schedule doesn’t work for you, you should not take this class. If you have any issues with attending class, please reach out to admin-mpcs@cs.uchicago.edu to discuss options for a leave of absence or withdrawal from the course.

Course Schedule

Skill-Building Projects

Week 1: Build & Deploy a Simple Website

• Course overview
• Intake survey
• Introduction to Claude Code
• Context management
• Environment setup:
• Terminal basics
• Git installation and configuration
• Package management
• Git fundamentals
• Build a simple site with Claude Code + Tailwind
• Deploy to web

Week 2: Build & Deploy an Interactive Tool                                                                            

• Review: git workflow, reading Claude's output                                                                   
• Handling user input                                                                                             
• Debugging fundamentals:                                                                                         
• Console logging                                                                                               
• Reading error messages                                                                                        
• Browser dev tools                                                                                             
• Understanding diffs: what did Claude change and why?                                                            
• Build an interactive tool                                     
• Deploy to web                                                                                                                                                                                                                              

Week 3: Build with an External API                                                                                

• Fetching data                                                                         
• Working with JSON                                                                                               
• Reading API documentation                                                                                       
• Error handling and edge cases                                                                                   
• Introduction to MCP servers                                                                                     
• Build an app that pulls from a real API (weather, sports, music, etc.)                                          
• Deploy to web     

 Week 4: Build with Auth + Database                                                                              

• Full-stack mental model: frontend ↔ backend ↔ database                                                          
• User authentication                                                                                
• Database basics with Supabase                                                                                   
• Writing and running tests                                                                                       
• Environment variables and secrets                                                                               
• Build an app with login and saved user data                                                                     
• Deploy to web                                                                                       

 Week 5: Project Kickoff

• What will you build?                     
• Draft vision for Week 10: what does done look like?                                                             
• Embrace imperfection: start with the smallest working version                                                   
• Set up project repo and environment                                                                             
• Begin building                    
  

 Weeks 6-9: Project Build

• Weekly cycle: build, deploy, share progress   
• Advanced topics: working with multiple agents, background agents                                                                  
• Workshops driven by what students need                                                                          
• Iterate based on feedback and what you learn                                                                    
• Progress over perfection
  

Week 10

• Launch projects & final presentations

Prerequisites

Required

• Core programming course requirement or placement exam.  Please review the prerequistes section listed further down on this page.

Not Required

• Prior design or software engineering experience.

Technologies & Tools

This class is designed to support student projects regardless of tech stack and external APIs used, however the recommended stack includes:

• AI-Assisted Development: Claude Code (primary)
• Frontend: Next.js (web) or React Native (mobile)
• UI: Tailwind CSS (web) or Nativewind (mobile)
• Database: Supabase
• Auth: Clerk or Supabase
• Deployment: Vercel (web), iOS App Store, Google Play Store

• External APIs:  OpenAI API, Anthropic API, etc., Project-specific APIs as needed.
• Model Context Protocol: Integrating AI with different systems to speed up development.

These tools are recommended due to their modern APIs, MCP tool availability, and low implementation overhead. Students using alternative tech stacks are encouraged to do so but should be comfortable iterating independently, with the instructor offering general support for planning and problem-solving.

If publishing an app in an app store, students may need to pay a registration fee to Google or Apple.

Must have completed MPCS 51036, 51040, 51042, 51046, 51100 or have a Core Waiver for Programming OR MACS 30122 OR CAPP 30235 or a CAPP 30235 waiver.

Required: Experience in at least one programming language, familiarity with Git, and terminal usage.

This course requires competency in Unix and Linux. If you attended the MPCS Unix Bootcamp you covered the required material. If you did not, please review the UChicago CS Student Resource Guide here: https://uchicago-cs.github.io/student-resource-guide/.

Course request information for non-MPCS students: https://masters.cs.uchicago.edu/student-resources/non-mpcs-student-course-requests/

This class is scheduled at a time that conflicts with these other classes:

• MPCS 51045-1 -- Advanced C++
• MPCS 56430-1 -- Introduction to Scientific Computing

MS in Computational Analysis in Public Policy (Year 1) MS in Computational Analysis in Public Policy (Year 2) MS in Molecular Engineering MA in Computational Social Science (Year 1) MA in Computational Social Science (Year 2) Bx/MS in Computer Science (Option 2: Professionally-oriented - CS Majors) Bx/MS in Computer Science (Option 3: Profesionally-oriented - Non-CS Majors) Masters Program in Computer Science