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. Agents raise the volume of code enormously, which makes the engineering practices that keep it trustworthy matter more, not less.
Day 1 makes behaviour verifiable. You write specifications precise enough to review an implementation against, then drive an agent through test-first development where the tests are strong enough to fail when the code is wrong. You go past the happy path into boundaries and invalid input, and add property-based testing to find the cases nobody thought of.
Day 2 is the machinery that stops quality decaying once you stop watching. 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. You then work on design, because the failure mode of agent-assisted work is near-identical logic accumulating until change becomes expensive.
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 want the engineering practices that keep a codebase reliable when an agent has written most of it.
Prerequisites
Working knowledge of Python, and some prior use of a coding agent such as Codex, Claude Code or Cursor. If you have not used an agent before, take Effective Vibe Coding for Beginners first.
You do not need prior experience with testing, type hinting or continuous
integration. Familiarity with git at the level of committing and branching
is assumed.
What You'll Learn
- Constrain an agent's output with tests that pin down behaviour rather than confirm whatever was written.
- Find the defects that review misses, using property-based testing and deliberate testing of invalid input.
- Use type hints and static analysis to catch defects before code runs.
- Enforce code quality automatically with Ruff, pre-commit hooks and a CI pipeline that runs your checks on every change.
- Keep an agent-written codebase maintainable, applying design principles that stop near-identical logic accumulating.
- 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
- Reviewing agent-written code for what tests cannot catch
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.