Intermediate Software Engineering with AI Agents
About This Course
A coding agent will hand you code that looks right, reads well and passes a cursory glance. Whether it is right is a separate question, and answering it is engineering work. Effective Vibe Coding for Beginners teaches you to steer an agent; this course is about the code at the end, and whether you can rely on it a year from now. An agent raises the volume of code you are responsible for without raising the time you have to read it, which is what makes these practices worth the two days.
Day 1 makes behaviour verifiable. You write a specification precise enough to review an implementation against, then drive an agent through test-first development, one stage at a time, where the tests are strong enough to fail when the code is wrong. You go past the happy path into boundaries and invalid input. The day ends on review, because tests only check what you thought to ask: you work through a layered checklist covering behaviour, safety, maintainability, verification and explainability, and learn the failure patterns that recur often enough to be worth looking for by name.
Day 2 is standard production engineering, applied to a codebase an agent largely wrote. Type hints and static analysis catch defects before anything runs. Ruff and pre-commit hooks apply your standards on every commit, and continuous integration applies them to every change, so the checks survive the week you stop paying attention. You spend time on packaging and project structure with uv, and on the design principles that keep a codebase changeable — duplication that accumulates a helper at a time is the sort of thing that is cheap to fix early and expensive later.
A case study takes a prototype through to a tested, automatically checked codebase. Along the way you handle the parts that separate a script from something other people depend on: errors that must not be silently swallowed, logging you can read after the fact, and secrets that should never have been in the repository. You should leave able to judge whether code an agent wrote is fit to ship, and with the checks in place to keep answering that question without rereading every line.
Who This Course Is For
Developers, data scientists, researchers and engineers who already use a coding agent and now need the code it produces to hold up in production. It suits people whose prototypes have graduated into things other people depend on, and who are reviewing more code than they wrote.
It also suits teams that have adopted agents faster than they have agreed on standards, where what gets merged depends on who reviewed it that day. The practices here are the ones a team can apply in common, and most of them run automatically once they are set up.
Prerequisites
This course is designed to be able to be completed immediately after completing Python Charmers' Introduction to Python course, or equivalent programming experience (approximately 3 months of regular usage).
You also need some prior use of a coding agent such as Codex, Claude Code or
Cursor, and familiarity with git at the level of committing and branching.
If you have not used an agent before, take our Effective Vibe Coding for
Beginners course first. No prior
experience with testing, type hinting or continuous integration is required.
What You'll Learn
- Write a specification precise enough to review an implementation against, and drive an agent from it test-first.
- Constrain an agent's output with tests that pin down behaviour rather than confirm whatever was written, covering boundaries and invalid input as well as the happy path.
- Review agent-written code against a five-layer checklist, and recognise the failure patterns that recur.
- Annotate a codebase with type hints and check it statically, catching defects before the code runs.
- Enforce code quality automatically with Ruff, pre-commit hooks and a continuous integration pipeline that runs your checks on every change.
- Handle errors, logging and secrets to a standard you can put in production.
Course Syllabus
Day 1: Making behaviour verifiable
- Specifications precise enough to review an implementation against
- Test-driven development with an agent, at production standard
- Testing beyond the happy path: boundaries and invalid input
- Property-based testing with Hypothesis, for the cases nobody listed
- Reviewing agent-written code for what tests cannot catch
- The failure patterns that recur, and the review loop that finds them
Day 2: Engineering for the long run
- Type hinting and static analysis
- Code quality and linting with Ruff
- Packaging and project structure with uv
- Continuous integration and pre-commit hooks
- Design principles that keep a codebase changeable
- Logging, error handling and managing secrets
A case study runs through the course, taking a prototype to a tested, automatically checked codebase.