I Built a Codex Skill That Tries to Teach You, Not Just Write Code

AI coding assistants can generate code, explain errors, and help implement features. But there is something I've been thinking about:

What happens when you can get code working but don't fully understand how it works?

I wanted to explore that problem, so I built an open-source Codex skill called ONE_FOR_ALL.

The goal is simple: make AI-assisted development more useful as a learning experience, not just a way to finish coding tasks faster.

The problem I wanted to solve

When working with an unfamiliar codebase, knowing what to change is only one part of the job.

You also need to understand:

• Which files are responsible for the feature?
• How does data flow through the application?
• Why does this implementation belong here?
• What could break if we change it?
• How do we verify that the solution actually works?

An AI assistant can help answer these questions, but the way it provides that help matters.

I wanted a workflow that encourages understanding the problem, planning the change, implementing it, and verifying the result.

What is ONE_FOR_ALL?

ONE_FOR_ALL is an open-source skill for OpenAI Codex, designed to act as a mentor for interns and early-career software engineers.

Instead of focusing only on generating code, it aims to explain the reasoning behind engineering decisions.

Some of the things it helps with include:

• Understanding codebases: Trace a feature through relevant files and understand its data flow.
• Working on tickets: Break a vague requirement into small, testable steps.
• Debugging: Investigate the evidence behind an error before choosing a fix.
• Learning system design: Understand component responsibilities, boundaries, dependencies, and trade-offs.
• Practising DSA: Work from a simple solution toward a more efficient one.
• Code review: Identify potential problems, edge cases, and useful tests.

The idea isn't to make every answer longer. It's to make the explanation useful enough that you can apply what you learned to the next problem.

A practical example

Suppose you're working on a React application and need to add validation to a signup form.

You could ask an AI assistant to implement the entire feature.

With ONE_FOR_ALL, you can instead start with:

$one-for-all Help me add validation to this signup form.

First, help me understand the existing implementation.
Identify the relevant files, explain the data flow,
and help me implement the change step by step.

The intended workflow is to understand the existing code, identify where the change belongs, explain the implementation, and suggest an appropriate way to verify it.

You can also use it when debugging an error, reviewing a diff, or learning a data structure.

These are the workflows the skill is designed to support; the actual result still depends on your codebase and the task.

How I structured it

I separated the skill's main instructions from supporting reference material.

The repository contains:

• SKILL.md — the main teaching workflow and task routing.
• references/project-work.md — project implementation and debugging.
• references/architecture-and-patterns.md — architecture and design patterns.
• references/dsa.md — data structures and algorithm problem-solving.
• references/early-career-engineering.md — tickets, onboarding, and code reviews.
• references/quality-and-delivery.md — testing, edge cases, and pull request readiness.

This structure keeps the main instructions focused while allowing more specific guidance for different engineering tasks.

What I want to improve next

I don't consider the skill finished just because the instructions are written.

I'd like to learn from people who try it on real projects.

Some questions I'm interested in exploring:

• Are the explanations useful, or do they create unnecessary verbosity?
• Does the workflow help developers understand unfamiliar codebases?
• Which parts of the development process need better guidance?
• How can the skill encourage learning without slowing down experienced developers?

Feedback based on actual usage would be especially useful.

Try it or contribute

The repository is available on GitHub:

ONE_FOR_ALL — GitHub repository

It's released under the MIT License, and contributions that improve the learning experience are welcome.

If you work with Codex, I'd be interested in hearing how you approach learning and understanding code while using AI coding assistants.

Disclosure: I used AI assistance to help draft and edit this article. The project and its goals are described from my own development work.