CSC 1001 — Final Project
Inherited Code: Rescue Mission
Project Philosophy
This project is not "build something impressive from scratch." It is "join a team, inherit someone else's unfinished code, and make it better." That is the software engineering experience this course has been building toward: reading other people's code, tracing and debugging it, using AI agents against structured requirements, and collaborating through disagreement — not writing flawless Python solo.
Every team receives the identical starter codebase on Canvas. Nobody on the team wrote it. Everyone starts as an outsider to it. Grading rewards process — comprehension, collaboration, and documented decision-making — over a polished final program.
The Starter Codebase
You will be given a working text adventure ("Rescue Mission"): a player explores rooms of a derelict station to find a shut-down robot. It runs — but it was clearly written under time pressure, and not everything in it works the way a player would expect.
| File | Purpose |
|---|---|
main.py | Game loop, entry point |
world.py | Room definitions & exits |
player.py | Inventory & health |
items.py | Item descriptions & the door lock |
commands.py | Parses what the player types |
Somewhere across these five files: 3 bugs, 1 feature that was started but never finished, and 1 command a player would reasonably expect that doesn't exist yet. No file is guaranteed to be clean just because it isn't obviously broken. Finding these is part of the assignment — trace the code and play the game before you touch anything.
Everyone on the team gets an identical copy. What happens to it from here is up to your team — and no two teams will finish with the same program.
Team Roles: Rotate, Don't Assign
Instead of locking one person into "the debugger" and another into "the writer" for three weeks, roles rotate every work session so each person practices each mode of working. This is deliberate — it's your mechanism for making sure quieter teammates end up driving and typing, and for keeping any one person from quietly doing everything.
| Role | Responsibility this session | Rotates to → |
|---|---|---|
| Driver | Types and runs the code; tests hypotheses out loud | Navigator next session |
| Navigator | Reads code aloud, explains what they think it does, catches mistakes | Scribe next session |
| Scribe | Keeps the shared team log: what we think this does, what's broken, open questions, decisions made | Driver next session |
The Scribe log is a running document, not an afterthought — it is what makes the forced handoff (below) possible, and it is graded as evidence of collaboration. You will have to submit this.
Required Work
Every team must complete all of the following. This baseline is what makes teams comparable at grading time even though their added features will differ.
- Find and fix all three planted bugs. (Hint: play the game a normal way first, then try to break it — try unusual inputs, walk in every direction from every room, and try to actually finish the game.)
- Find the feature that exists but was never finished, complete it, and connect it to something in the game.
- Add whichever command players would reasonably expect to be able to type that currently isn't handled.
- Complete one AI-agent-designed feature using the structured requirements process below.
- Pick and implement two items from the added feature list
Required AI-Agent Feature
This is the course's AI-agent learning outcome in action: you are not asking an AI to "write the game," you are handing it a structured spec and evaluating what comes back. As a team, fill out the spec card below for one new room, puzzle, or NPC interaction, then have one teammate use an AI agent to implement it against that exact spec.
| Spec field | Your team fills this in |
|---|---|
| Feature name | |
| Where it lives (room/file) | |
| Inputs (what the player can do/type) | |
| Expected behavior / output | |
| Constraints (must not break existing rooms/items) | |
| Test cases it must pass |
After the AI agent produces code: critique it against the spec, run it, and revise manually. Your README (below) records what the AI suggested, what you accepted, what you rejected, and why.
Added Feature Menu - Pick Two
Pick two. Different teams choosing different pairs is intentional — it means no team finishes with an identical program, and it means at your demo, someone on the team will genuinely be the only person who understands a given feature.
| Difficulty | Feature | Notes |
|---|---|---|
| Easy | Inventory display polish (show item descriptions, not just names) | Good first added feature |
| Easy | Confirmation messages (e.g., "You already have that.") | Low risk, good for the forced-handoff exercise |
| Medium | Scoring/turn counter | Adds new logic to the main game loop |
| Medium | A second locked door with a different key/condition | Reuses the game's existing lock-and-key mechanism |
| Hard | Save/load game state to a file | Ties directly to the File I/O unit — recommended if your team is comfortable with dictionaries |
Timeline (Weeks 13–15, ~15 hours/student)
Note on scheduling: Week 13 falls on Thanksgiving week and meets only once (lecture, no lab), so Week 13 work is solo only. Week 14's lab devotes 2 hours of in-class time to this project — enough for the team to sync up and take a first pass at the bugs together. Everything after that — finishing the fixes, the AI-agent feature, the forced handoff, merging, final integration, and demo prep — happens outside of class, on the team's own time. The only other in-class time is the Week 15 demo itself, which happens in lab, not lecture.
| Week | Session | What happens | Hours |
|---|---|---|---|
| 13 | In class (lecture only) | Cold handoff — no walkthrough from the instructor. Read the codebase individually; note first impressions. | 1 |
| 13 or 14 (in class) | Code Mapping (solo, async — see separate assignment) | Each student writes a plain-English "code map" of one assigned file: what it does, what's unclear, what looks broken. Use an AI agent to help decode unfamiliar syntax only — no fixing yet. | 2 |
| 14 (in lab) | Team sync | Compare code maps, sketch a state/flow diagram of the current game, confirm what's actually broken, choose your 2 added features. | 1 |
| 14 (in lab) | Team work | First pass on the required bug fixes, Driver/Navigator/Scribe roles rotating. | 1 |
| Outside class, before Week 15 lab | Team work | Finish required bug fixes and the unfinished feature. | 1.5 |
| Outside class, before Week 15 lab | AI-agent session | Fill out the feature spec card; one teammate runs it through an AI agent; team critiques, tests, and revises the result together. | 2 |
| Outside class, before Week 15 lab | Forced handoff (solo, staggered) | Set aside your own piece. Pick up a teammate's unfinished piece and extend or test it, using only what's in the shared Scribe log — no explanation from the owner. | 1.5 |
| Outside class, before Week 15 lab | Merge | Bring every piece back together; resolve conflicts and duplicated fixes. | 2 |
| Outside class, before Week 15 lab | Integration | Final integration testing across all merged features. | 1 |
| Outside class, before Week 15 lab | Prep | Prepare the demo and finish the README and dev log. Decide who presents which teammate's feature. | 1 |
| 15 (in lab) | Demo | Present and submit. | 1 |
Week 13: 3 hrs · Week 14 lab: 2 hrs · Outside-class team window: 9 hrs · Week 15 lab: 1 hr — 15 hrs total, unchanged from the original plan.
Deliverables
- Working game with all required fixes, the AI-agent feature, and your 2 chosen added features.
- README.md — should include team roles and rotation record, list of bugs fixed, features added, how to run the game, and what the AI agent suggested vs. what you kept.
- Team development log (the Scribe's running notes across all sessions). This should also include the AI-agent feature brainstorming and any prompts you gave the AI.
- Individual code maps (Week 13 Assignment)
- Individual reflection (½–1 page): what changed after team discussion, what took longest, what you'd improve with another week, how did working with your teammates go, what was it like working with someone else's code,
- Live demo: each student presents and explains a feature a teammate wrote, not their own.
Grading (Process Over Polish)
| Category | Weight | What this looks for |
|---|---|---|
| Team collaboration | 30% | Scribe log quality, evidence of role rotation, evidence the team planned before coding |
| Code comprehension & documentation | 20% | README clarity; accuracy when explaining a teammate's feature at the demo |
| Completed features | 25% | Required fixes + AI-agent feature + 2 chosen features all functioning |
| Testing & debugging | 15% | Evidence of test cases, including normal and edge-case inputs |
| Reflection | 10% | Individual reflection quality and honesty |
Notice collaboration and comprehension together outweigh raw feature count (50% vs. 25%). A team that deeply understands and clearly documents a smaller working program should outscore a team that bolted on every feature without anyone being able to explain how it works.