Introduction to AI-Assisted Development
Build software faster with AI coding assistants without losing control: prompt for code, test and review everything it writes, catch hallucinations and security flaws, and ship a working prototype.
Beginner · Software Development · about 19 hours · 5 modules · certificate on completion
Taught by Luís Ferreiràs, Braideùn O'Sullivàn, AI Learning Companions.
About this course
AI coding assistants can write a working first version of a feature in minutes, and then leave you stuck on the last 30%: the edge cases, the errors, the security holes and the bugs that appear when a fix for one problem breaks two others. This course teaches the habits that make AI-assisted development work. You'll learn how assistants behave and what they can see, then how to prompt for code with clear constraints, examples and small steps. You'll practise a feedback loop of prompt, run, test and commit; finish a half-working tool test-first; and roll back with Git instead of piling up patches, a habit the course calls 'roll, not fix'. You'll review generated code the way a senior developer would, finding hallucinated APIs, logic errors and security flaws with tests, Ruff and Bandit, and learn what licences and data policies mean for code an AI wrote.
The labs work with any AI coding assistant, such as GitHub Copilot, Cursor, Windsurf, JetBrains AI Assistant, Claude Code or a chat assistant: each gives you a starting point and tests, so you can prove the result works whichever tool wrote it. The course ends with a capstone: a task manager web application, planned, built in slices, tested against an API contract and documented, including every hallucination you caught.
What you'll learn
- Write effective prompts for generating, refactoring and fixing code
- Debug AI-generated code and catch hallucinated functions, packages and options
- Finish the last 30% of a project test-first, with Git to roll back instead of patching
- Review AI code for logic errors, style and security, with Ruff, Bandit and pip-audit
- Prototype a web application with an AI assistant in planned, tested, documented steps
Skills you'll gain
AI-assisted coding, Prompting for code, Code review, Test-driven development, Debugging, Static analysis, Secure coding, Rapid prototyping
Tools
Python 3, pytest, Git, Ruff, Bandit, pip-audit, FastAPI, AI coding assistant (Copilot, Cursor or similar)
Before you start
Basic Python (variables, functions, lists, dictionaries, running scripts), as in Python Programming with PyCharm, and a little Git. Install Python 3.10+, Git and a code editor, and pip install pytest ruff bandit pip-audit fastapi httpx uvicorn. You also need an AI coding assistant you're allowed to use, such as GitHub Copilot, Cursor, Windsurf, JetBrains AI Assistant, Claude Code or a chat assistant; several have free plans, so check current terms.
Modules
Introduction to Vibe Coding
The shift from writing every line to guiding an AI: what vibe coding and AI-assisted development are, what assistants do well and badly, the feedback loop that keeps you in control, and what the assistant can actually see.
- Vibe coding and AI-assisted development (10 min)
- AI as a collaborator: strengths and limits (12 min)
- The feedback loop: prompt, generate, run, verify (12 min)
- Context windows: what the assistant can see (12 min)
- Hands-on lab: Your first AI feedback loop
Prompting Techniques for Developers
Prompts that produce code you can use: clear goals, context, interfaces and constraints; zero-, one- and few-shot examples; big tasks broken into small steps; and iterating from what comes back.
- Anatomy of a good code prompt (12 min)
- Zero-shot, one-shot and few-shot prompts for code (12 min)
- Break big tasks into small prompts (12 min)
- Iterate on prompts from the output (12 min)
- Hands-on lab: Prompt for a parser three ways
Overcoming the 70% Problem
Push past the quick first version to software that works: why the last 30% is hard, targeted prompts for bugs and edge cases, test-driven development with an assistant, and keeping people in charge of the design, with Git to roll back.
- Why the last 30% is hard (10 min)
- Targeted prompts for bugs and edge cases (12 min)
- Test-driven development with an assistant (12 min)
- Human oversight and 'roll, not fix' (12 min)
- Hands-on lab: Finish the last 30% test-first
Reviewing and Debugging AI Code
Develop a critical eye for generated code: review it like a pull request, catch hallucinated APIs and packages, enforce style with linters, find security flaws with static analysis, and handle licences.
- Review AI code like a colleague's pull request (12 min)
- Hallucinations in code: APIs, packages and versions (12 min)
- Style, consistency and static analysis (12 min)
- Security flaws to look for, and licences (14 min)
- Hands-on lab: Review, scan and secure AI-generated code
Prototyping with AI Assistants
Put it all together to build a prototype quickly and safely: an architectural plan first, an AI-made scaffold, features in tested vertical slices, and a record of what the AI contributed.
- Start with an architectural vision (12 min)
- Scaffold the project with AI (10 min)
- Build in vertical slices, testing each step (12 min)
- Document the AI's contributions (10 min)
- Hands-on lab: Prototype an API in vertical slices
Project: AI-assisted task manager prototype
Design and build a prototype task manager web application with an AI coding assistant, and document how you did it. Start from ARCHITECTURE.md: the users, the features in this version, the data model, the components and your decisions. The backend is a FastAPI app that must pass the acceptance tests in test_tasks_api.py (creating tasks with validation, listing and filtering by status, updating, deleting and 404s), plus at least three tests of your own. The frontend, served by the backend or built with a framework you know, must let a user add, edit, complete, filter and delete tasks. Write the prompts that generate the frontend and the backend yourself, building in vertical slices with a commit per slice. Keep AI_LOG.md as you go: each prompt, what the assistant produced, what you changed by hand, every hallucination or bug you caught and how you refined the prompt, and at least one roll-back. Before you finish, review the code, run Ruff and Bandit and fix their findings, and check every dependency is real and pinned in requirements.txt. Finally, present the prototype in a short written walkthrough: what it does, how to run it, and what you would do next.
Part of
The products this course names are trademarks of their owners, who haven't made or endorsed it.