CMU 15-281: Artificial Intelligence: Representation and Problem Solving
15-281 is CMU's core AI course — search, constraint satisfaction, linear and integer programming, Markov decision processes, reinforcement learning, and game-theoretic reasoning — with programming assignments that implement the algorithms against real problem environments.
Fennie is independent and not affiliated with Carnegie Mellon University. This is an unofficial study guide.
Build my 15-281 study planWhat makes it hard
Each unit is a different modeling formalism with its own machinery, and the course moves through them fast. The recurring exam skill is formulation — casting a scenario as a search problem, CSP, or MDP — which is harder than executing any single algorithm. Assignments demand both correct math and code that works against autograded environments, failing on different schedules.
What you'll cover
- • State-space search and heuristics
- • Constraint satisfaction
- • Linear and integer programming
- • Markov decision processes
- • Reinforcement learning
- • Game theory and adversarial reasoning
The 15-281 study guide
How to study for CMU 15-281, step by step.
- 1
Learn each formalism's components cold
States, actions, constraints, objectives, rewards — every unit is a modeling language with required parts. Being able to list and instantiate them is the prerequisite for everything else.
- 2
Practice formulation, not just execution
Take scenarios and cast them as search problems, CSPs, or MDPs yourself before touching solution algorithms. Exams weight the modeling step heavily, and homework templates quietly do it for you.
- 3
Trace the algorithms by hand on small cases
A*, constraint propagation, value iteration — run each on paper for tiny examples. Exam questions ask for intermediate values, and hand-simulation is also how the algorithms become intuitive.
- 4
Split each assignment's math and code early
The written and programming halves fail differently: derivations need thought-time, autograder code needs debug-time. Start both early enough that neither can borrow from the other's budget.
- 5
Connect the units at their boundaries
Search becomes MDPs when uncertainty enters; CSPs and LPs are siblings in formulation. Exam questions love the boundaries — build the comparison map explicitly as the semester accumulates.
- 6
Cover the formalisms with Fennie
Upload your 15-281 syllabus and Fennie's Daily Plan paces each unit's formalism and assignment across the semester so nothing gets crammed, with quizzes generated from the actual course content. Free to start.
Start my 15-281 plan free
How Fennie helps with 15-281
Fennie's Daily Plans pace 15-281's formalism-after-formalism structure so each modeling language is solid before the next arrives, with assignment deadlines tracked across their math and code halves. Chat through casting scenarios as search problems or MDPs — the formulation skill the exams actually weight.
FAQ
Is 15-281 hard?
The breadth is the challenge: a new modeling formalism every couple of weeks, assignments demanding both derivations and working code. Students who practice formulating problems themselves — not just running algorithms — handle the exams; the formulation step is where grades separate.
What's the difference between 15-281 and 10-301?
281 is AI's decision-making side — search, optimization, MDPs, game theory — while 10-301 is machine learning: models learned from data. They're complementary, share probability foundations, and many students take both; neither substitutes for the other.
What should I know before taking 15-281?
Solid programming (15-122 level), probability fundamentals, and comfort with mathematical formalism — 21-127's maturity helps more than any specific theorem. The algorithms aren't individually deep; juggling five formalisms at CMU pace is the real prerequisite.
Pass 15-281 with a plan, not a cram
Upload your 15-281 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore CMU courses
15-112 — Fundamentals of Programming and Computer Science
15-112 is CMU's famous fast-paced introduction to programming in Python — control flow, functions, data structures, recursion, OOP, and efficiency — ending in an open-ended term project. Its public course website and the related CMU CS Academy platform give it a search footprint far beyond Pittsburgh.
15-110 — Principles of Computing
15-110 is CMU's gentler introduction to computing — Python programming plus computing concepts like data representation, algorithms, and the limits of computation — designed for students who aren't CS majors or who want a runway before 15-112. It's one of the largest courses on campus.
15-122 — Principles of Imperative Computation
15-122 teaches imperative programming with correctness front and center — contracts, loop invariants, and reasoning about code in the C0 teaching language before transitioning to real C — covering data structures from stacks and queues through hash tables, trees, and graphs. It's the second course of the CMU CS core.
15-150 — Principles of Functional Programming
15-150 teaches functional programming in Standard ML — types, recursion and induction, higher-order functions, and reasoning about programs as mathematical objects — alongside 15-122 in the CMU CS core. For most students it's the first time programming and proof become the same activity.