The assignment is intended for a CS1 course after students have learned basic control flow, functions or methods, collections, file input, and simple classes or modules. Students should also have had at least a brief introduction to automated testing.

The project is especially suitable for courses reconsidering learning goals in the context of generative AI. Students may complete the implementation without AI, use AI only after requirements and design work, or use AI throughout while remaining responsible for evaluating assumptions, testing behavior, and explaining their decisions.

The coding difficulty is intentionally moderate for CS1. Most individual components require straightforward use of conditionals, arithmetic, collections, file loading, and small classes or functions.

The conceptual difficulty is higher because students must recognize ambiguity, prioritize questions, reason about interactions among components, and distinguish requirement problems from implementation problems. The assignment can be completed in a single 90–115 minute structured lesson with reduced implementation scope, or as a multi-day project with a complete implementation and larger test suite.

The assignment shifts student attention from code production toward specification, design, testing, and communication. This makes it useful in an environment where code generation is increasingly inexpensive but evaluating whether generated code is correct remains essential.

The limited Product Manager question budget encourages prioritization and strategic communication. Students must decide which uncertainties are important enough to spend a question on rather than asking for implementation help.

The required separation into components makes program structure visible and creates natural opportunities for both unit and integration testing. Tests act as executable statements of what students believe the requirements mean.

The intentionally imperfect data and requirements create productive ambiguity: students can discover inconsistencies before coding, during component testing, or when individually correct pieces fail to integrate.

The same instructional structure can be reused with different themes, allowing instructors to preserve assessment and facilitation materials while changing the story or domain.

Some students may initially perceive intentionally ambiguous requirements as unfair if the instructional purpose is not explained clearly. The instructor must distinguish between productive ambiguity and arbitrary hidden expectations.

Facilitation requires preparation: the Product Manager should use a consistent answer key, and instructors should avoid accidentally revealing teacher-only ambiguity notes.

A single early interpretation can affect many downstream calculations. Grading therefore needs to avoid repeatedly penalizing the same root misunderstanding when the rest of a student's implementation is internally consistent.

Students need a working Python or Java development environment. Starter ZIP files are provided for both languages, along with CSV data files, source-file scaffolding, and starter unit and integration tests.

No external libraries are required. Python uses the standard library and unittest; Java can be compiled and run with a standard JDK using the provided package structure.

If generative AI is part of the activity, instructors should specify when AI use is permitted and what planning, decision-log, testing, or reflection artifacts must be produced independently.

The project can be run as a short in-class activity, a multi-day team project, a testing-focused exercise with partial implementations, or an AI-explicit assignment in which students evaluate generated code against their own requirements and tests.

The same design can be remixed into other themes while preserving the underlying ambiguities and component interactions. Possible alternatives include:

• disaster-relief supply distribution,
• interplanetary travel booking,
• a fantasy potion marketplace,
• wildlife rehabilitation and treatment scheduling,
• campus event registration and pricing.

Difficulty can be increased by reducing starter scaffolding, requiring students to design their own CSV schema, adding malformed input files, increasing the number of interacting components, or asking students to write acceptance tests for another team's implementation.

The assignment works best when requirements analysis is treated as a first-class activity rather than a prelude to coding. Give students time to inspect the specification before they are allowed to ask Product Manager questions or begin implementation.

The instructor should resist answering engineering questions in the Product Manager role. A useful response is: “That is an engineering decision; what product behavior do you need clarified?”

Encourage students to record assumptions and connect each important requirement to at least one test. During integration, ask students to identify whether a failure comes from code, an interface mismatch, or a disagreement about the specification.

If AI is allowed, a productive structure is to require students to freeze an ambiguity log, question list, architecture sketch, and initial tests before using a code generator. The debrief can then focus on where generated code made unsupported assumptions and how testing exposed them.