Software Engineering with AI

Beyond the chatbox: what AI assistants really are

How the model "thinks" — and why it changes how you ask

The capability map: what AI does brilliantly

The limits: hallucination, freshness, and what never to trust it with

Your first real win: turn a 30-minute task into 3

Context is everything: give it what it needs to know

Give it a role and a goal

Constraints and format: define what "good" looks like

Show, don't tell: examples and templates

Iterate like a pro: steer, don't restart

Documents and reports: summarise, extract, and draft better

Spreadsheets and data: Excel formulas, analysis, and charts

Presentations: from blank page to a solid deck

Long, messy input: transcripts, threads, notes, and screenshots

ChatGPT, Claude, Copilot, Gemini: which to reach for, and when

Make smarter decisions: AI as your thinking partner

Chaining steps: multi-part tasks done reliably

Your prompt library: reusable templates that save hours

Staying safe: privacy, accuracy, and company data

Capstone: do a real task end-to-end (graded) → your certificate

What this course assumes you can already do

Reading a stack trace

Git survival kit: branch, commit, revert

Your environment: terminal, editor, and one AI coding tool

If this is too soon: where to start instead

What the model actually sees

The harness is the product

Specification over instruction

Reading AI code critically: the four failure signatures

Context engineering: what to include, exclude, and when to restart

Reading a codebase you didn't write

Debugging when the AI is wrong

Data structures and complexity: spotting quadratic generated code

Version control as a safety net

Testing as specification

Mapping an unfamiliar codebase with an agent — and verifying what it tells you

Refactoring where behaviour must not change

Migrations at scale — the mechanical work AI is genuinely great at

Conventions you did not choose

When the suggestion is right but the change is wrong

Models as components — capability, latency, cost per task

The API surface — messages, system prompts, streaming, structured output

Prompt engineering that survives production

Multimodal inputs — screenshots, PDFs, voice, and screenshot-to-code

Tokens and money — cost per request, caching, when cheap is enough

Failure modes — hallucination, refusal, truncation, and their guardrails

Why models need your data — the knowledge-cutoff problem

Embeddings and vector search — what similarity measures, and where it fails

Chunking is the whole game

Building a RAG pipeline: ingest, embed, store, retrieve, ground

State and memory: history, summarisation, what to persist

Beyond a single call: chains, routing, and when complexity earns its place

Tool use: giving the model capability, and bounding it

The agent loop: plan, act, observe, and how to stop it

Control flow: retries, fallbacks, timeouts and partial failure

Multi-step workflows: decomposition, parallelism and where the human sits

Non-determinism as an engineering discipline

Evals: proving it works

Guardrails: input validation, output checks, injection defence

Observability: tracing a request, debugging a bad answer in production

Deploying an AI feature: secrets, rate limits, streaming UI

What you can legally ship: IP, licence contamination, disclosure, employer policy

The security of AI-generated code

Securing the agent: prompt injection, the confused deputy, permission scoping

Using AI to improve security: review, dependency triage, threat modelling

Cloud agents: remote execution, isolation, credentials off your laptop

Building a software factory: parallel agents, decomposition, repeatability

The human gate at scale: review policy, team conventions, disclosure norms