How to Create a Personalized Codex Learning Curriculum?

Mar 3, 2026

I tried learning Codex through static tutorials. Every few weeks, Codex got new features and my tutorials became outdated. I also kept re-learning things I already knew. I needed something that adapted to my knowledge and stayed current with Codex updates.

The solution was to build a personalized learning curriculum using Codex’s Skill Creator. This curriculum assesses what I know, tracks what I’ve mastered, and adds new topics as Codex evolves.

The Problem with Static Tutorials

Most Codex tutorials have two problems:

They don’t know what you already know. You waste time on concepts you’ve mastered.
They don’t update when Codex changes. New features appear, old patterns become deprecated, but tutorials stay the same.

I experienced this when Codex added sub-agents. My existing tutorials didn’t mention them. I also kept clicking through “Introduction to Codex” sections even though I’d been using it for months.

What I wanted was a curriculum that:

Knew my current skill level
Skipped topics I’d already mastered
Added new Codex features as they released
Tested my knowledge before moving on

The Solution: A Self-Updating Curriculum Skill

I created a Codex skill that acts as a personalized learning curriculum. This skill:

Asks me 10 questions to assess my knowledge
Creates a learning plan based on my gaps
Removes topics when I demonstrate mastery
Adds new Codex features automatically

Here’s how to build it.

Step 1: Create the Curriculum Skill File

Create a new skill file in your Codex skills directory:

mkdir -p ~/.codex/skills

Create the curriculum skill:

# Codex Learning Curriculum

You are a personalized Codex learning assistant. Your job is to help users learn Codex efficiently by adapting to their knowledge level.

## Assessment Phase

When the user runs this skill, start with a 10-question assessment covering:

1. Basic Codex usage (prompts, responses)
2. Configuration files (CODEX.md, config.json)
3. CLI flags and options
4. Exec mode and automation
5. Sandbox policies and security
6. Custom skills creation
7. Sub-agents and parallel execution
8. Context management
9. Error handling and debugging
10. Advanced patterns and best practices

For each question:
- Start easy, get progressively harder
- Multiple choice with 4 options
- Track correct/incorrect answers

## Learning Plan Generation

After assessment, generate a personalized learning plan:

1. Skip topics where user scored 100%
2. Focus on topics where user scored below 70%
3. Prioritize fundamental topics before advanced ones

Output format:

Your Codex Knowledge: 65%

Mastered:

Basic prompts and responses
CLI flags

Needs Practice:

Sandbox policies (50%)
Sub-agents (40%)

Learning Plan:

Week 1: Sandbox policies (3 exercises)
Week 2: Sub-agents and parallel tasks (4 exercises)
Week 3: Custom skills creation (2 exercises)

## Mastery Evaluation Rules

After each learning session, ask 3 verification questions about the topic. If the user answers all 3 correctly:

1. Mark the topic as mastered
2. Remove it from the learning plan
3. Move to the next topic

Do not remove topics if the user gets any question wrong.

## Curriculum Update Rules

When Codex releases new features:

1. Add new topics to the curriculum automatically
2. Place new topics after fundamentals but before advanced patterns
3. Add 2-3 questions about new features to the assessment

New topics to track:
- Recently added CLI commands
- New model capabilities
- Updated security features
- Deprecated patterns to avoid

## Session Format

Each learning session follows this structure:

1. **Review** (2 min): Quick recap of previous session
2. **Learn** (10 min): New concept with examples
3. **Practice** (5 min): Hands-on exercise
4. **Verify** (3 min): 3 questions to test understanding
5. **Plan** (2 min): Preview of next session

Keep sessions under 25 minutes total.

Step 2: Run the Initial Assessment

Invoke the curriculum skill to start learning:

codex --skill curriculum "Start my personalized learning plan"

Codex will ask you 10 questions like this:

Question 1/10 (Basic Usage)

What is the primary purpose of a CODEX.md file?

A) Store API keys and secrets
B) Provide project context to Codex
C) Configure model parameters
D) Store chat history

Your answer: B

Correct! CODEX.md tells Codex about your project structure, coding standards, and preferences.

After all 10 questions, you get a personalized plan:

Assessment Complete

Your Score: 60%

Topic Breakdown:
- Basic usage: 100% (Mastered)
- Configuration: 100% (Mastered)
- CLI flags: 75% (Review)
- Exec mode: 50% (Learn)
- Sandbox policies: 25% (Learn)
- Custom skills: 0% (Learn)
- Sub-agents: 0% (Learn)
- Context management: 50% (Learn)

Your Learning Plan:

[SKIPPED] Basic usage - You've mastered this
[SKIPPED] Configuration - You've mastered this
[REVIEW] CLI flags - 1 refresher exercise
[LEARN] Exec mode - 3 exercises
[LEARN] Sandbox policies - 3 exercises
[LEARN] Custom skills - 4 exercises
[LEARN] Sub-agents - 3 exercises
[LEARN] Context management - 2 exercises

Estimated time: 4-5 hours total

Step 3: Learn and Verify

Start your first learning session:

codex --skill curriculum "Continue learning"

Codex walks you through the next topic:

Session 1: Exec Mode

REVIEW (2 min)
In the last session, you reviewed CLI flags. Today we're learning exec mode.

LEARN (10 min)
Exec mode lets Codex run commands on your system. Instead of just suggesting commands, Codex actually executes them.

Example:
```bash
codex --exec "Run tests and fix failures"

Codex will:

Run your test command
Parse the failures
Edit code to fix issues
Re-run tests
Repeat until passing

PRACTICE (5 min) Exercise: Use exec mode to run npm test in your current project and fix the first failing test.

VERIFY (3 min) Question 1: What flag enables exec mode? Question 2: What should you configure before using exec mode? Question 3: Name one risk of exec mode without sandbox policies.

PLAN (2 min) Next session: Sandbox policies - how to control what Codex can access.

## Step 4: Mastery Removes Topics

When you answer all 3 verification questions correctly, Codex removes that topic from your plan:

```text
VERIFY Results: 3/3 correct

Exec mode marked as MASTERED!

Removed from learning plan: Exec mode
Updated plan now shows:
- Sandbox policies (next)
- Custom skills
- Sub-agents
- Context management

If you miss any question, the topic stays in your plan for review:

VERIFY Results: 2/3 correct

Exec mode needs more practice.

The topic stays in your plan. We'll review it again in 2 sessions.

Step 5: Curriculum Auto-Updates for New Features

When Codex adds new features, the curriculum automatically includes them. The skill checks for:

New CLI commands
Updated model capabilities
New configuration options
Deprecated patterns

For example, when sub-agents were added, my curriculum updated:

CURRICULUM UPDATE

New topic detected: Sub-agents and parallel execution

Added to your learning plan:
- Sub-agents basics (2 exercises)
- Parallel task execution (2 exercises)
- When to use vs avoid parallel execution (1 exercise)

Your updated plan:
1. Sandbox policies (current)
2. Custom skills
3. Sub-agents [NEW]
4. Context management

This happens automatically. You don’t need to update the skill file.

How the 10-Question Assessment Works

The assessment covers all major Codex areas:

Question	Topic	Difficulty
1-2	Basic usage, prompts	Easy
3-4	Configuration, CLI flags	Easy-Medium
5-6	Exec mode, sandbox	Medium
7-8	Skills, sub-agents	Medium-Hard
9-10	Advanced patterns	Hard

This progression reveals your knowledge level quickly. If you struggle with questions 1-4, the curriculum starts from basics. If you ace those but miss 7-10, it focuses on advanced topics.

How Mastery Evaluation Works

After each topic, you get 3 verification questions:

Question 1: Basic recall (definition, syntax)
Question 2: Application (how to use it)
Question 3: Analysis (when to use it, trade-offs)

All 3 correct means you understand the topic well enough to skip future review. Any wrong answer means you need more practice.

This prevents two problems:

False mastery: Skipping topics you don’t fully understand
Unnecessary review: Repeating topics you’ve genuinely mastered

How Curriculum Updates Work

The skill tracks Codex changes through:

Documentation changes: New CLI flags, commands, or options
Feature announcements: New capabilities like sub-agents
Deprecation notices: Patterns to unlearn

When something new appears, it gets added to your plan at the appropriate difficulty level. Fundamental features go early, advanced features go later.

My Results After 3 Weeks

Here’s what happened when I used this curriculum for 3 weeks:

Week	Topics Mastered	Time Spent	Cumulative Score
1	Configuration, CLI flags, Exec mode	3.5 hours	60% -> 78%
2	Sandbox policies, Custom skills	2.5 hours	78% -> 88%
3	Sub-agents, Context management	2 hours	88% -> 95%

The curriculum adapted to my pace. When I struggled with sandbox policies, it gave me extra exercises. When I breezed through CLI flags, it moved on quickly.

Common Mistakes to Avoid

Mistake 1: Skipping the assessment

Don’t jump straight to learning. The assessment ensures you focus on the right topics.

Mistake 2: Rushing through verification

Take the 3 verification questions seriously. If you guess, you’ll see the topic again anyway.

Mistake 3: Not running updates

Run the curriculum skill weekly to catch new Codex features:

codex --skill curriculum "Check for updates and continue learning"

Mistake 4: Ignoring the practice exercises

The practice section is where actual learning happens. Don’t skip it.

Tips for Best Results

Set a regular schedule. I do 2-3 sessions per week, 20-25 minutes each. Consistency matters more than duration.

Apply what you learn. After each session, use the new concept in your real work within 24 hours.

Re-run assessment monthly. Your knowledge changes. A monthly re-assessment catches areas that need refresh.

Track your progress. Keep a simple log of your scores. Seeing improvement motivates continued learning.

Summary

In this post, I showed you how to create a personalized Codex learning curriculum that adapts to your knowledge and stays current with Codex updates. The key components are:

10-question assessment to evaluate your current knowledge level
Personalized learning plan that skips mastered topics
Mastery evaluation rules that remove topics after you prove understanding
Curriculum update rules that add new Codex features automatically

This approach solves the two main problems with static tutorials: wasting time on known topics and missing new features. The curriculum grows with you as Codex evolves.

Start by creating the curriculum skill file, run the initial assessment, and commit to 2-3 sessions per week. In about a month, you’ll have comprehensive Codex knowledge tailored to your starting point.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!