AI curriculum

Course outline for AI-Assisted Software Development

Revisit the software development lifecycle from C01 and examine how AI changes the way teams plan, implement, review, test, and integrate software. Use AI on a real change, revise effort estimates, and compare automated and human review. Explore an issue-to-merge workflow and decide where fuller automation improves delivery, where it shifts work, and where human decisions remain necessary.

AI-Assisted Software Development Course Objectives

  • Compare conventional and AI-assisted SDLC activities, roles, and feedback loops.
  • Estimate AI-assisted work using uncertainty, verification, review, and rework.
  • Implement and independently check a real AI-assisted repository change.
  • Evaluate automated code-review findings and decide when human review is needed.
  • Compare assisted, partially automated, and issue-to-merge workflows.
  • Define justified automation and merge boundaries using risk and observable evidence.

Pre-requisites

  • Software Engineering Foundations for AI Engineers or equivalent knowledge of SDLC, planning, estimation, reviews, CI/CD, and environments.
  • Programming Language Concepts for AI Engineers or equivalent ability to program, review a diff, and run independent tests.
  • Artificial Intelligence Foundations and Applied Generative AI or equivalent understanding of AI limitations and effective prompting.
  • No particular coding assistant or harness-implementation experience is required.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Readiness checks

  • Software Engineering Foundations for AI Engineers or equivalent knowledge of SDLC, planning, estimation, reviews, CI/CD, and environments.
  • Programming Language Concepts for AI Engineers or equivalent ability to program, review a diff, and run independent tests.
  • Artificial Intelligence Foundations and Applied Generative AI or equivalent understanding of AI limitations and effective prompting.
  • No particular coding assistant or harness-implementation experience is required.

Software Engineering Foundations for AI Engineers or equivalent knowledge of SDLC, planning, estimation, reviews, CI/CD, and environments.

Find your place in the learning map

Lab Setup

Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

Git, a code editor, runtime/tests, a small disposable repository, and authorized model access for coding and automated review. Provide a minimal issue-to-merge runner, an isolated target branch, simple CI-style checks, and explicit merge rules. Actual model generation and review are required; prepared defect examples support diagnosis, not replacement of those runs. No production secrets, remote merge permissions, or deployment access are required. Verify isolation, access, quotas, and runner behavior before delivery.

Detailed Course Outline

Module 1: Replan the lifecycle when AI joins the team (2 hours)

  • Lifecycle recap: Software Engineering Foundations for AI Engineers recap: requirements, design, planning, implementation, testing, delivery, and maintenance.
  • Issue triage: AI-assisted issue triage, repository exploration, requirements, and acceptance criteria.
  • Architecture and decomposition: Architecture suggestions, simpler alternatives, and task decomposition.
  • Responsibilities and handoffs: Changed responsibilities and handoffs between people, models, and deterministic checks.
  • Estimation ranges: Estimation ranges: context preparation, generation, verification, review, rework, and waiting.
  • Feedback and re-estimation: Small changes, feedback, uncertainty, and re-estimation from observed results.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Map the changed workflow and estimate one issue with explicit assumptions and review capacity.

Module 2: Implement and evaluate automated review (2 hours)

  • Generation and refactoring: Actual code generation, debugging, and behavior-preserving refactoring.
  • Independent tests: Independent unit, integration, and acceptance tests; checking generated tests.
  • Deterministic checks and AI review: Static analysis, formatting, and security checks versus probabilistic code review.
  • Review findings: AI reviewer findings: missed defects, false positives, evidence, and reproducibility.
  • Correlated mistakes: Correlated mistakes when code generation and review share models or assumptions.
  • Human review: Human review for intent, architecture, security, maintainability, and consequential changes.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Correct a generated patch and adjudicate automated-review findings against code and tests.

Module 3: From issue to merge: how far to automate? (2 hours)

  • Issue-to-merge stages: Issue readiness, plan, branch, implementation, tests, review, revision, and merge.
  • Workflow controls: Deterministic workflow controls around variable model-generated code and findings.
  • Checks and bounded repair: CI checks, documentation updates, bounded repair attempts, and escalation.
  • Merge rules: Risk-based merge rules, branch protections, secrets, and least-privilege execution.
  • Whole-process trade-offs: Potential throughput gains versus review queues, cost, false acceptance, and ownership gaps.
  • Merge and deployment: Merge versus deployment; staging validation, release decisions, recovery, and monitoring feedback.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Run a prepared issue-to-merge path and justify which stages and merges can proceed automatically.

Practical exercise

  • Use a small repository issue, such as adding a configurable export option. First map its Software Engineering Foundations for AI Engineers-style lifecycle and propose an AI-assisted workflow. Estimate effort as a range, with separate assumptions for context preparation, generation, testing, review, repair, and waiting. Do not apply an arbitrary AI speed multiplier or convert an old story-point estimate directly into elapsed time.
  • Use a selected coding assistant to explore, implement, debug, and improve the change. Run an automated AI code review and deterministic checks. Investigate both a real or seeded defect and a plausible but unsupported review finding. Keep acceptance criteria independent of generated tests and reviewer agreement.
  • Use a prepared automation runner to take a structured issue through planning, branch creation, actual model-generated edits, tests, review, and a merge decision. Demonstrate an accepted low-risk change and a failed or higher-risk change that stops for human action. If the approved lab policy permits automatic merge, perform it only into a disposable local target branch; otherwise demonstrate the enforced merge gate without claiming a merge occurred. Update documentation, record actual effort, and revise the initial estimate. Decide whether assistance, partial automation, or fuller automation fits this task and team.

Delivery and timing

  • Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.

What you will produce

Implement and independently review an AI-assisted change, then justify its issue-to-merge automation boundary.

How the work is checked

  • The workflow comparison names which C01 activities, roles, and handoffs change.
  • Estimates include review, rework, uncertainty, and waiting rather than generation time alone.
  • The actual patch meets independently specified acceptance criteria.
  • Review findings are accepted or rejected using inspected code and test evidence.
  • The automation trace shows actual stage outcomes and a correctly enforced merge decision.
  • Different correct implementations can pass; broken constraints still block the change.
  • The automation recommendation explains benefits, costs, suitable issue types, and human responsibilities.
  • Revised estimates distinguish observed lab effort from claims about team-wide productivity.

6 guided hours. A small repository change with prepared issue-to-merge infrastructure. Learners configure and evaluate automation, not build a production orchestrator. Actual model generation and automated review are required. Test success and model agreement alone do not justify merging. Production deployment is not performed.

When another approach is better

  • Do not delegate code review when you cannot independently understand and test the affected behavior.
  • Use a stable script rather than repeated model generation for a known deterministic verification step.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals