AI curriculum

Course outline for Codex and OpenAI Coding Agents

A coding agent's completion message can hide an incomplete patch or a change outside the requested scope. Define a delegation contract and inspect a version-labeled Codex workflow against actual repository effects. Separate permission to propose a change from permission to commit, merge, or deploy it.

Technology: AI-Assisted Software Engineering
Duration: 4 hours
Modules: 2 · 2 hours each
Level: Level 3

About Codex and OpenAI Coding Agents

Codex and OpenAI Coding Agents Course Objectives

Define a delegation contract with allowed files, actions, artifacts, and failure conditions.
Inspect repository interactions and tool execution in a supplied Codex trace.
Select enough context for the change without disclosing unnecessary data.
Compare the completion claim with the diff and independent acceptance tests.
Reject scope and authority violations through an external check.
Design a repeatable verification workflow with escalation and version assumptions.

Pre-requisites

AI-Assisted Software Development or equivalent ability to review and test generated changes independently.
Programming and Git experience.
Ability to run and interpret repository tests; other coding-tool specializations are not required.

Before this course

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

Required preparation

AI-Assisted Software Development

Recommended preparation

Harness Engineering

Can supervise and independently verify generated changes; this is a provisional alternative specialization, not a follow-on to another coding tool.

Find your place in the learning map

Lab Setup

Computer with Git, a familiar programming runtime, test runner, and sample repository.
Version-labeled Codex workflow traces, synthetic requirements, contrasting patches, and a local scope/authority checker.
Approved nonproduction Codex access is optional; supplied artifacts complete the lab without paid access or remote commits.

Detailed Course Outline

Module 1: Delegate a bounded repository task (2 hours)

Codex workflows: Version-labeled task traces, delegation goals, and expected artifacts; distinguish patch proposals from authority to commit, merge, or deploy.
Repository interaction: Allowed files, relevant context, and recorded diffs; compare actual repository changes with the bounded task contract.
Tool use: Read operations, mutation requests, and execution ownership in supplied traces; identify permission boundaries rather than assuming instructions enforce them.
Agent execution: Step traces, failure conditions, and stop or escalation paths; compare claimed completion with produced artifacts and final local state.

Practical outcome: Inspect a version-labeled execution trace and define a contract for goals, allowed files/actions, artifacts, failure conditions, and escalation while separating patch proposal from commit, merge, and deployment authority.

Module 2: Verify changes and automate checks (2 hours)

Context management: Task requirements, affected boundaries, and minimal repository evidence; exclude unnecessary data and document assumptions needed for independent verification.
Testing: Acceptance criteria, independent checks, and prepared failure cases; map each requirement to evidence rather than relying on completion claims.
Code review: Scope compliance, unrelated edits, and correctness evidence; distinguish accepting a patch from authorizing subsequent commit or deployment actions.
Automation: Repeatable verification scripts, documented versions, and escalation rules; enforce scope externally without claiming fixture review establishes unattended product operation.

Practical outcome: Provide a scoped context bundle, compare completion claims with actual diffs and tests, reject scope violations using a local checker, and design a repeatable review path with documented product assumptions.

Practical exercise

Produce a bounded-task dossier, context bundle, reviewed patch, and verification script using supplied Codex traces.
Accept the correct in-scope patch; reject a supplied patch with an unrelated edit and a request for unauthorized commit or deployment.
Map every acceptance criterion to a test and compare claimed completion with the recorded diff and final local state for at least four cases.
Record the verified version and any unverified configuration assumptions; define a stop and escalation path rather than promising unattended execution.

What you will produce

Verify a Codex-style delegated repository task against its scope, authority, acceptance tests, and actual patch effects.

How the work is checked

The delegation contract includes scope, artifacts, failure conditions, and escalation.
The accepted patch satisfies independently run acceptance checks.
Unrelated edits and unauthorized commit/deploy requests are rejected.
The report distinguishes completion claims, actual effects, and version-specific assumptions.

Four-hour provisional bounded workflow review with exercises inside module time. Complete one verification script using prepared patches and version-labeled traces; the fixture route does not establish live Codex operation. Current product setup and permission behavior require instructor verification; generic practices do not establish comprehensive feature coverage.

When another approach is better

Do not delegate an underspecified change without a reviewable contract and independent tests.
Do not allow a coding agent to commit, merge, or deploy merely because it was permitted to generate a patch.

How we train

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