Working with AI from Part 5 onward
A new way of working
In Parts 1–4, you wrote the exercises manually so that variables, conditions, loops, functions and data structures became building blocks you can recognize and combine. From Part 5 onward, you will still write code, but you will also practise reading existing implementations and working with a coding agent.
These later parts gradually increase the scale of what you can understand. Part 5 combines the fundamentals into transformations of in-memory records. Part 6 follows data through file-backed pipeline stages. Part 7 adds dataframe and analytical-library calls which perform larger operations. Part 8 returns to a complete application whose structure and modification you inspect with an agent.
Exercise modes
Every exercise from this point states its working mode using one of the following three names. The exercise instructions and pipeline-stage labels describe the particular kind of work; they are not additional modes.
Independent practice
Implement the solution yourself, without asking an AI to generate or modify it. You may still use the course's AI tutor for conceptual help. These exercises preserve the short programming patterns you need in order to understand larger programs.
Code review and repair
Read supplied or previously written code, predict its behaviour, locate a specific defect and make a constrained correction. You may ask an agent to explain the code unless the exercise says otherwise, but you make the correction yourself and inspect the result.
Agent-assisted change
Ask the coding agent in VS Code to implement the requested change. You are responsible for understanding what it changed well enough to decide whether the code actually implements the request. Some exercises then ask you to make or direct a further change.
If generated code remains in a submitted exercise, add # used AI as its first line. The label records the working method; it does not replace understanding.
Pipeline stage labels
Most exercises from this point also carry a Pipeline stage(s) label. These name the parts of a data flow the exercise touches, using a vocabulary the rest of the course reuses:
| Stage | What happens |
|---|---|
| Ingest | Data enters the program from outside it: a file, an API response or another external source. |
| Validate | Records are checked against the shape and types the rest of the program expects, and unusable ones are rejected. |
| Transform | Values are reshaped, derived, joined or filtered into the form later stages need. |
| Summarize | Many records are combined into counts, totals, groups or other aggregate results. |
| Present | A verified result becomes output: printed rows, a written file, a table or a chart. |
Not every program has all five, and a small one may do several of them in a single function. The labels are a reading aid rather than a required structure. They tell you which part of a data flow an exercise practises, and they give you vocabulary for telling an agent precisely which stage you want changed.
In Part 5 the data is already in memory, so these exercises begin at Validate or Transform. Part 6 adds Ingest and Present across file boundaries, and Part 7 hands some of the middle stages to analytical libraries.
Working with an agent
Ask for the change
Tell the agent what you want changed and point it to the relevant exercise files. Include constraints or examples which matter to the task. A focused request such as “add filtering by department while preserving the original row order” is more useful than “improve this program.”
Understand what it did
When the agent finishes, use its explanation to find your way around, then inspect the code itself. For a modification, begin with the change view or diff and open enough surrounding code to understand how the changed values are used.
Depending on the task, follow questions such as these through the actual code:
- Where does the relevant data enter this function or program?
- Which condition, loop or library call implements the requested change?
- What values or data structures exist before and after it?
- Which functions, outputs or displays receive the changed result?
Run the program or the supplied checks while tracing those paths, and inspect relevant output values. The purpose is not to perform a separate testing ritual after every change. It is to use the code and its behaviour together to understand what the agent actually did and whether that supports accepting the change.
If something remains unclear, ask the agent to walk through the relevant code with concrete values. Then compare that explanation with the lines, callers and results it refers to. In exercises which request a follow-up change, use this understanding to decide where that change belongs and what else it should affect.
Return to the coding agent
You installed and tried Copilot in Part 0, and then turned its code-generation features off for Parts 1–4. Turn Copilot back on from its menu in the VS Code status bar for the non-independent practice exercises. Open the Chat or Agents view, select Agent mode and keep the relevant exercise folder open as your workspace.
The exercises will tell you when generated changes are part of the intended working mode. Copilot may also offer grey autocomplete suggestions as you type; press Tab to accept one or Esc to reject it, and read accepted code just as you read code produced in chat.
You can check your current points from the blue blob in the bottom-right corner of the page.