Systems focus
Students learn the engineering layer around AI: API contracts, context management, backend security, deployment, observability, and cost control.
CSCI 3XXX
Practical AI Systems & API Design
Design, build, deploy, and evaluate AI-powered web applications with secure API boundaries and responsible engineering practice.
14 weeks
Project-based
Free-tier deployable
Security + evals
Course rationale
Applied AI systems for web application students.
This course complements AI and ML theory by teaching students how to integrate foundation-model APIs into reliable, secure, deployed software systems.
Evidence of learning
Every major milestone produces an inspectable artifact: working code, a deployed URL, a design explanation, and documented evaluation results.
Responsible practice
Students practice safe API use, prompt-injection awareness, privacy-sensitive design, failure documentation, and human-centered AI UX.
Studio format
Short briefings, then hands-on systems work.
Class time is organized around applied builds, critique, and debugging. Students practice the engineering judgment behind AI applications, not only the vocabulary around models.
- Live code walkthroughs connect API behavior to architecture decisions.
- Students work in teams, deploy frequently, and review each other's systems.
- Discussion focuses on reliability, cost, safety, and how to explain tradeoffs.
What you will build
From first AI call to final deployed project.
The course compounds: each build adds a production concern you need in real AI software.
Week 2
First deployed AI app
Week 4
Secure backend with API proxy
Week 6
RAG system over real documents
Week 7
Live MVP midterm
Week 9
Multi-step agent
Week 10
Eval harness
Week 14
Final deployed project
The stack
Free-tier tools, real production shape.
Students learn the same moving parts that power modern AI applications: UI, API boundary, model calls, data, search, deploys, and version control.
React + Vite
FreeFrontend
UI layerCloudflare Pages
FreeDeployment
Static hostingCloudflare Workers
FreeBackend / API proxy
Secure edge APIAnthropic API
~$5 totalAI calls
Model layerSupabase
FreeDatabase + Vector search
Data layerGitHub
FreeVersion control
Team workflowStudent outcomes
What students can demonstrate by the end.
The final work is designed to show implementation skill, architecture judgment, responsible API use, and the ability to evaluate an AI system beyond a polished demo.
Build and deploy
Develop a working AI-powered web application with a frontend, secure backend API boundary, database layer, and public deployment URL.
Explain the system
Produce a concise architecture brief that documents data flow, model calls, security controls, cost assumptions, and design tradeoffs.
Evaluate behavior
Create an evaluation report with test cases, failure analysis, regression checks, and recommendations for improving reliability and user trust.
Assessment
How learning is measured.
Assessment emphasizes repeated practice, technical correctness, design reasoning, responsible deployment, and clear communication.
Studio participation
Attendance, peer feedback, code review participation, and professional collaboration habits.
Build checkpoints
Weekly and sprint-based submissions covering API integration, backend security, RAG, agents, and deployment.
Evaluation and safety report
Test cases, failure documentation, cost analysis, prompt-injection review, and responsible-use considerations.
Final project review
Live demo, code quality, architecture explanation, operational readiness, and reflection on limitations.
Syllabus
14 weeks of applied AI systems work.
A visible week-by-week schedule with the technical focus, class activity, and evidence of learning shown up front.
Week 1
What is an AI System
Students learn to treat AI as one component inside a larger software system: user interface, API boundary, model provider, data layer, monitoring, security, and evaluation.
- In class
- Map a real AI product into frontend, backend, provider, storage, and risk surfaces.
- Deliverable
- Account setup, starter repo, and a one-page architecture sketch for the first app.
Week 2
APIs & First Deployed App
Students practice REST, JSON, HTTP status codes, and browser fetch patterns, then ship a small AI-powered interface to a public Cloudflare Pages URL.
- In class
- Trace request and response flow from UI action to API response and rendered result.
- Deliverable
- A live deployed app with clear loading, success, and failure states.
Week 3
Context Engineering
Students design prompts as software interfaces, with explicit roles, constraints, examples, token budgets, and structured outputs that downstream code can parse safely.
- In class
- Compare vague prompts against schema-driven prompts and measure reliability differences.
- Deliverable
- A prompt contract that returns validated JSON for a real application workflow.
Week 4
Backend & Security
Students move AI calls behind a Cloudflare Worker so API keys stay off the client, inputs can be validated, and abuse controls can be applied before model calls run.
- In class
- Build an API proxy with secrets, CORS rules, request validation, and rate-limit thinking.
- Deliverable
- A secured backend endpoint connected to the deployed frontend.
Week 5
Model Selection & Cost
Students compare model quality, latency, streaming behavior, and per-request cost so model choice is justified by product requirements instead of hype.
- In class
- Benchmark the same task across model options and estimate cost under realistic usage.
- Deliverable
- A model decision memo with latency, quality, and cost tradeoffs.
Week 6
RAG
Students build retrieval-augmented generation over real documents, learning chunking, embeddings, vector search, citation handling, and context injection limits.
- In class
- Load documents into Supabase pgvector and inspect retrieved context before generation.
- Deliverable
- A document-grounded assistant that cites retrieved sources and handles missing answers.
Week 7
Midterm
Students demonstrate a live minimum viable product and receive structured feedback on usability, architecture, reliability, cost exposure, and project scope.
- In class
- Run peer demos, review deployment behavior, and convert feedback into an issue backlog.
- Deliverable
- A public MVP URL, short demo script, and prioritized improvement plan.
Week 8
Multimodal APIs
Students extend beyond text by evaluating when vision, transcription, and document understanding APIs create value and what privacy constraints they introduce.
- In class
- Prototype one multimodal feature and inspect file handling, error cases, and consent language.
- Deliverable
- A working multimodal interaction or a justified decision not to include one.
Week 9
Agents
Students implement tool calling and multi-step control flow while learning the operational limits of agents: state, retries, timeouts, logging, and error recovery.
- In class
- Build an agent loop that calls a controlled tool and explains each step in logs.
- Deliverable
- An agent feature with bounded actions, observable traces, and failure handling.
Week 10
Evals
Students learn that AI quality must be tested, not guessed, by creating golden datasets, LLM-as-judge rubrics, regression checks, and failure documentation.
- In class
- Write evaluation cases that capture correctness, groundedness, refusal behavior, and UX quality.
- Deliverable
- An eval harness with 20 or more test cases and a baseline report.
Week 11
Security
Students analyze prompt injection, data leakage, unsafe tool use, over-broad permissions, and responsible deployment obligations for public AI applications.
- In class
- Red-team sample prompts and document mitigations at the prompt, API, and UI layers.
- Deliverable
- A threat model and mitigation checklist for the final project.
Week 12
AI UX
Students design interfaces that set expectations, show progress, communicate uncertainty, recover from errors, and make AI behavior inspectable to users.
- In class
- Improve streaming, empty states, citations, retry flows, and user trust cues in the MVP.
- Deliverable
- A UX pass that turns the project from demo into usable application.
Week 13
Project Communication
Students turn technical work into professional evidence by explaining architecture, tradeoffs, eval results, cost controls, and scope in language reviewers can trust.
- In class
- Workshop architecture diagrams, resume bullets, demo narratives, and final risk disclosures.
- Deliverable
- A one-page architecture document and polished final-demo plan.
Week 14
Final Demo Day
Students present a deployed AI system as a portfolio artifact, defending design choices, reliability evidence, cost assumptions, and known limitations.
- In class
- Live demos with instructor, peer, and guest reviewer feedback using a shared evaluation rubric.
- Deliverable
- Final URL, source repo, architecture document, eval report, and reflection on next steps.
Course instructor
Mira Yun, Ph.D.
Professor of the Practice · Computer Science Faculty
- Office
- 245 Beacon Street 509
- Telephone
- 617-552-3686
- mira.yun@bc.edu
- Department
- Boston College Computer Science
Prerequisites
Come in ready to build for the web.
Web + systems route
CSCI 2254
Web Application Development
CSCI 2271
Computer Systems
Best fit for students who have built web applications and understand the systems layer that supports deployed software.
Software engineering route
CSCI 3356
Software Engineering
Best fit for students with team software project experience, code review practice, and application design exposure.
- Comfortable writing JavaScript for interactive web applications.
- Have seen a REST API and understand request/response data flow.
- Ready to use GitHub, deploy code, and debug across frontend/backend boundaries.
No prior machine learning coursework is required. Model training is not the focus; the course teaches how to design and evaluate applications that use AI APIs responsibly.