Build evidence
Students produce a public application, readable source history, and working backend boundary instead of stopping at a local demo or slide deck.
CSCI 3XXX · Practical AI Systems & API Design · Fall 2027
Build a live AI system you can defend in interviews.
An upper-level Computer Science course where students ship production-shaped AI applications, document the architecture, test model behavior, and turn the work into credible hiring evidence.
Live deployed app
Architecture brief
Eval report
Interview-ready demo
Course rationale
Not AI hype. Evidence students can show.
This course complements AI and ML theory by teaching students how to integrate foundation-model APIs into secure, deployed software systems and explain the work in clear, professional language.
Show judgment
Students practice explaining architecture, model choice, cost, latency, security, and failure modes so the project holds up under technical questioning.
Earn trust
Students document safe API use, prompt-injection risks, privacy-sensitive design, test coverage, and responsible deployment constraints.
Class format
Briefings, builds, critiques, and demos.
Class time is organized around applied builds, technical review, 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 deploy frequently, review examples, and receive feedback on their systems.
- Discussion focuses on reliability, cost, safety, and how to explain tradeoffs in interviews.
Hiring proof
What employers can actually inspect.
The course is designed around artifacts that make a student easier to evaluate: working software, clear reasoning, and evidence that the system was tested instead of merely demoed.
Live deployed application
A public URL with real user flows, loading and error states, secure API routing, and a final demo script.
Architecture story
A one-page system design brief covering data flow, model calls, security boundaries, cost assumptions, and tradeoffs.
Evaluation evidence
Twenty or more test cases, documented failures, regression checks, and an explanation of what should improve next.
Weak project signal
Built a chatbot using the Claude API.Stronger interview signal
Designed and deployed a RAG-based research assistant with a secure API proxy, Supabase pgvector retrieval, cost controls, and an eval harness that documents accuracy, failures, and improvement paths.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
Tools chosen for production-shaped learning.
The stack is intentionally constrained so students spend less time choosing tools and more time learning the moving parts employers expect: 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
Version historyStudent outcomes
What students leave ready to show.
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.
Learning outcomes
Measurable outcomes students can prove.
By the end of the course, students should be able to demonstrate practical AI systems competency through observable artifacts and defensible technical decisions.
Design an AI-powered web application with explicit frontend, backend, model, data, and deployment responsibilities.
Protect API keys and user inputs through server-side proxying, validation, rate-limit thinking, and responsible access boundaries.
Use retrieval, structured outputs, and model-selection criteria to connect AI behavior to application requirements.
Evaluate model behavior with repeatable test cases, failure analysis, regression checks, and clear quality criteria.
Communicate architecture, tradeoffs, limitations, and cost assumptions in a format suitable for technical interviews and project review.
Assessment
How learning is measured.
Assessment emphasizes repeated practice, technical correctness, design reasoning, responsible deployment, and clear communication.
Class 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 visible build evidence.
Each week pairs technical concepts with a concrete artifact, so students can see their progress and explain what they have learned.
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 project scope clearly.
- 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 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.