AI curriculum

Course outline for Codex and OpenAI Coding Agents

Use Codex to explore, change, test, and review a repository. Shape its behavior through project instructions, commands, skills, hooks, and integrations. Manage context and permissions, delegate bounded work, and build a repeatable workflow. Learn the Codex-specific steps for the same engineering concepts taught in the Claude Code and OpenCode courses.

Codex and OpenAI Coding Agents Course Objectives

  • Configure a scoped session and complete a checked repository change.
  • Use session commands, project instructions, skills, and explicit context records.
  • Connect an MCP tool and customize behavior through supported extensions.
  • Delegate independent work and execute a bounded adaptive workflow.
  • Automate a repeatable task and investigate actual execution results.
  • Review correctness, permissions, context use, effort, and recovery behavior.

Pre-requisites

  • AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.
  • Programming, Git, terminal use, and repository build/test commands.
  • No prior MCP knowledge is required; the course introduces it before integration.
  • Harness Engineering helps with Agent Skills and harness concepts but is not mandatory.
  • Claude Code Engineering and OpenCode and Open Agentic Coding Tools are alternatives, not prerequisites.

Before this course

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

Required preparation

Recommended preparation

Readiness checks

  • AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.
  • Programming, Git, terminal use, and repository build/test commands.
  • No prior MCP knowledge is required; the course introduces it before integration.
  • Harness Engineering helps with Agent Skills and harness concepts but is not mandatory.
  • Claude Code Engineering and OpenCode and Open Agentic Coding Tools are alternatives, not prerequisites.

AI-Assisted Software Development or equivalent AI-assisted development, independent testing, and review competence.

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.

A verified stable Codex CLI, authorized inference access, runtime/tests, Git, a disposable repository, controlled MCP service, prepared extension, and small orchestration wrapper. Verify CLI commands, hooks/plugins, delegation, and structured-output support on the selected release. Label unavailable desktop and hosted features comparison-only. No production push or merge rights are needed.

Detailed Course Outline

Module 1: Establish a controlled repository session (2 hours)

  • CLI and IDE setup: CLI installation, authentication, model choice, and IDE entry points.
  • Local and hosted responsibilities: Local execution, hosted tasks, and client/server responsibilities.
  • Project configuration: AGENTS.md guidance, config.toml scope, approvals, and sandbox boundaries.
  • Repository change: Repository exploration, acceptance criteria, planning, edits, and test commands.
  • Verification and recovery: Diff inspection, independent verification, and Git-based recovery.
  • 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: Produce and test a small patch with visible scope and permission decisions.

Module 2: Commands, skills, context, and memory (2 hours)

  • CLI command discovery: Discover CLI slash commands and distinguish desktop-only features.
  • Session configuration commands: /init, /plan, /permissions, /model, and /status during repository work.
  • Session continuation: /compact, /resume, /fork, and explicit task handoffs.
  • Reusable skills: /skills and reusable SKILL.md instructions, references, and deterministic helpers.
  • Disclosure and memory: Progressive disclosure, relevant files, persistent guidance, and memory controls.
  • Shortcuts and effort: Reusable task shortcuts, context limits, usage, and reasoning-effort choices.
  • 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: Invoke a reusable task and continue it using an inspected context record.

Module 3: Tools, MCP, hooks, and customization (2 hours)

  • MCP participants: MCP basics: host, client, server, tools, resources, and prompts.
  • Integration routes: Built-in tools, direct API access, and MCP integration choices.
  • MCP transports: Codex MCP configuration for local STDIO and remote Streamable HTTP.
  • Connection diagnosis: Authentication, connection state, denied calls, and unavailable-service diagnosis.
  • Lifecycle hook: A supported lifecycle hook around a harmless repository check.
  • Trusted extensions: Plugin discovery, trusted installation, and reusable extension components.
  • Configuration precedence: Configuration precedence, extension scope, disabling changes, and secret handling.
  • 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: Exercise an MCP tool and a scaffolded extension with observable behavior.

Module 4: Delegation and adaptive workflows (2 hours)

  • Subagents and roles: Subagents, custom agent roles, separate contexts, and result review.
  • Background work and isolation: Background work, worktree isolation, shared-file conflicts, and coordination costs.
  • Task decomposition: Decompose a task into independent investigations and dependent changes.
  • Explicit branching wrapper: Branch on checked results using a small explicit orchestration wrapper.
  • Worker limits and resume: Monitor workers, bound retries and concurrency, stop, and resume safely.
  • Native and external orchestration: Native delegation versus external orchestration; limits of feature equivalence.
  • 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 delegated workflow with an explicit branch and independently checked worker artifacts.

Module 5: Repeatable automation, review, and diagnosis (2 hours)

  • Non-interactive execution: codex exec, explicit inputs, structured results, and JSON event capture.
  • Code review: /diff, /review, and non-interactive codex review.
  • Checks and bounded repair: Fixed checks around variable proposals and bounded repair attempts.
  • CLI diagnosis: CLI diagnostics, configuration inspection, and client/server orientation.
  • Continuation and effects: Interrupted tasks, session continuation, completed effects, and rerun safety.
  • Merge boundary: A repeatable change-and-review workflow with an explicit merge boundary.
  • 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: Rerun a bounded task, diagnose a failure, and verify the actual patch and tests.

Practical exercise

  • Improve a small repository with a configurable export option. Use Codex commands to plan and control the session, apply AGENTS.md guidance, and invoke a reusable skill. Connect a provided MCP service and exercise a supported scaffolded hook or plugin component. Inspect its effective configuration and actual output.
  • Delegate an independent investigation. Run a small prepared wrapper that branches on checked results and invokes Codex for the dependent work. Inspect the orchestration logic, monitor results, and rerun it on changed input. Use a disposable workspace to investigate interruption and continuation. Finally use codex exec for a bounded task, capture its events, run code review, and check the diff and tests independently. Record effort and review costs.

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

Configure Codex and run checked repository work, integrations, delegation, and repeatable CLI automation.

How the work is checked

  • Actual product execution produces a patch that meets independent acceptance criteria.
  • Commands and skills are invoked with relevant inputs and inspectable results.
  • MCP and a supported extension are exercised, including a failure or denial.
  • Delegated workers run and their outputs receive independent review.
  • The orchestration branch uses checked results rather than assumed success.
  • Non-interactive evidence distinguishes process completion from task correctness.
  • The final automation retains permission, test, and merge boundaries.

10 guided hours. A standalone Codex specialization. Local CLI execution is required; hosted features are comparison-only unless arranged. Adaptive orchestration uses supported delegation and an explicit wrapper, not an assumed Claude-style runtime. Required extensions need stable support. App-server internals are orientation, not an experimental API build.

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

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