Skip to main content
plugin CX Codex

codex-howto — Claude Code plugin: what it does, how to install

codex-howto is a plugin for Claude Code and Codex with nine skills that take Codex tasks from scoping through tests and diff review to an evidence handoff. It takes work beyond code generation.

MIT ★ 1,596 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install codex-howto@awesome-codex-plugins
Open on GitHub

What codex-howto does

The plugin ships nine Codex skills: frontend, backend, DevOps, testing, security, review, and bounded orchestration. Its flagship engineering-loop keeps one task on rails. Reproduce or baseline first, then the smallest change, focused checks, required checks, a diff review, and a handoff that says what is still unverified. A course runs alongside it, from the mental model and sandbox up to working scenarios; the Codex Living Wiki keeps reviewed decisions inside the repo.

Install in Claude from the marketplace: /plugin marketplace add hashgraph-online/awesome-codex-plugins, then /plugin install codex-howto@awesome-codex-plugins. Codex users have a separate route: npx skills add Phelan164/codex-howto --skill engineering-loop -g -a codex -y. Reading the skill source before installing is the author's advice, and so is the dependency-free five-minute playground in labs/engineering-playground.

Loading all nine at once is the wrong move. The repo says a lifecycle skill can add more context than value when you only need one bounded defect fixed, so pick the smallest piece that changes the outcome. Run receipts from the GPT-5.6-sol experiments sit in the repo for a reason: a skill does not make a task cheaper on its own.

What it helps with

  • carry a fix from reproduction to a reviewed diff
  • cap the context and subagents one task pulls in
  • split a large job into independent parts with integration checks
  • keep team decisions in a wiki tied to sources
  • measure whether a skill helped on your own stack

Example prompts for the agent

  • $engineering-loop take this change end to end, then report the commands you ran and what stayed unverified.
  • Which parts of this task are independent? Check the orchestration decision matrix before splitting it.
  • Add the caching decision to the Codex Living Wiki with a link to the source.

How to install codex-howto

Plugin marketplace

/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install codex-howto@awesome-codex-plugins

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about codex-howto

How do I install Claude-howto in Claude Code?

Add the marketplace with /plugin marketplace add hashgraph-online/awesome-codex-plugins, then run /plugin install codex-howto@awesome-codex-plugins.

What does Claude-howto do?

It gives Claude nine skills covering frontend, backend, DevOps, testing, security, review and orchestration. The flagship engineering-loop drives a change through checks and an evidence handoff.

Do I need all nine skills?

No. The author advises starting with the smallest set that can change the outcome, since a lifecycle skill adds context you may not need for one bounded defect.

Source text

codex-howto · MIT
# Codex How To

Turn Codex from a code generator into a verifiable engineering workflow.

This engineering-first guide takes a task through scoping, implementation,
testing, review, and evidence—with focused workflows for frontend, backend,
DevOps, security, and multi-agent orchestration.

## What you get

- Learn Codex progressively, from its mental model and sandbox to advanced
  engineering workflows.
- Install focused skills for frontend, backend, DevOps, testing, security,
  review, and bounded orchestration.
- Run changes through baseline, implementation, tests, diff review, and an
  evidence handoff.
- Limit unnecessary context, agent fan-out, conflicting edits, and retries.
- Measure whether a skill or multi-agent workflow actually improved the task.

**New to Codex?** Run the dependency-free
[five-minute playground](labs/engineering-playground/README.md).
**Already using Codex?** [Install `engineering-loop`](#try-the-engineering-loop).
**Want a quick improvement?** Try [10 practical Codex tips](resources/codex-tips.md)
with copy-ready prompts and guidance on when each helps.

![Codex How To: from scope through evidence](assets/social-preview.svg)

[![Validate](https://github.com/Phelan164/codex-howto/actions/workflows/validate.yml/badge.svg)](https://github.com/Phelan164/codex-howto/actions/workflows/validate.yml)
[![Release](https://img.shields.io/github/v/release/Phelan164/codex-howto)](https://github.com/Phelan164/codex-howto/releases/latest)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![skills.sh](https://skills.sh/b/phelan164/codex-howto)](https://skills.sh/phelan164/codex-howto)
[![Engineering Loop security](https://skillstore.io/badges/skills/phelan164-engineering-loop/security.svg)](https://skillstore.io/skills/phelan164-engineering-loop)
[![Engineering Loop score](https://skillstore.io/badges/skills/phelan164-engineering-loop/score.svg)](https://skillstore.io/skills/phelan164-engineering-loop)

[Start learning](modules/00-mental-model/README.md) ·
[Try the engineering loop](#try-the-engineering-loop) ·
[See measured results](#what-the-seed-measurements-show) ·
[Browse all skills](#engineering-skill-catalog) ·
[Fork a tested edition](resources/fork-an-edition.md) ·
[Contribute](#contributing)

> **Status:** active. Latest release: [v0.6.0](https://github.com/Phelan164/codex-howto/releases/tag/v0.6.0).
> Content was checked against official Codex documentation on 2026-07-31.
> Codex changes quickly; verify settings and commands through the links marked
> **Official source**.

## Choose the smallest workflow that fits

Do not install every skill by default. Start with the minimum guidance that can
change the outcome of your task:

| Your task | Start here | Use it when |
|---|---|---|
| Learn Codex from first principles | [Mental model](modules/00-mental-model/README.md) | You need the progressive course, sandbox model, prompts, tools, and verification basics |
| Fix one bounded defect | [Testing and review](modules/07-testing-and-review/README.md) | The scope and acceptance check are already clear; a lifecycle skill may add more context than value |
| Deliver a multi-surface feature | [`engineering-loop`](skills/engineering-loop/SKILL.md) | Implementation, testing, review, and evidence must stay connected through one verified loop |
| Split a large task safely | [Orchestration decision matrix](resources/orchestration-decision-matrix.md) | Work has genuinely independent ownership surfaces and integration checks |
| Preserve team know-how | [Codex Living Wiki](knowledge/README.md) | Repeated research and decisions should become reviewed, source-grounded repository knowledge |

Unsure? Run the [five-minute playground](labs/engineering-playground/README.md)
before installing anything globally.

### Use it, verify it, improve it

1. **Use it:** [install the flagship loop](#try-the-engineering-loop) or run the
   [dependency-free playground](labs/engineering-playground/README.md).
2. **Verify it:** inspect the [raw task receipts](examples/measurements/engineering-loop-runs.csv)
   before trusting an efficiency claim.
3. **Improve it:** [fork the repository](https://github.com/Phelan164/codex-howto/fork),
   run the same evaluator on your stack, and contribute a sanitized result.

If the workflow saves you a failed iteration, [star the repository](https://github.com/Phelan164/codex-howto)
to follow new measurements. A fork is most useful when it produces a
reproducible task, evaluator, correction, translation, or workflow profile—not
just another copy.

## Try the engineering loop

Install the flagship skill with the community
[skills.sh installer](https://skills.sh/phelan164/codex-howto):

```bash
npx skills add Phelan164/codex-howto --skill engineering-loop -g -a codex -y
```

Start a new Codex task in a small, version-controlled project:

```text
$engineering-loop Implement this change end to end. Continue through focused
tests, required checks, diff review, and verified fixes. Report the commands
run, evidence produced, and anything that remains unverified.
```

Expect a baseline, a bounded implementation, focused and required checks, a
final diff review, and an evidence handoff—not just generated code. Inspect the
[skill source](skills/engineering-loop/SKILL.md) before installing it, or use
the dependency-free
[five-minute playground](labs/engineering-playground/README.md) first.

## See the engineering loop

```mermaid
flowchart TD
    subgraph Understand["1 · Understand"]
        direction LR
        A["Scope the task"] --> B["Reproduce or baseline"]
    end

    subgraph Build["2 · Change and verify"]
        direction LR
        C["Make a small change"] --> D["Run focused checks"] --> E["Run required checks"]
    end

    subgraph Finish["3 · Review and finish"]
        direction LR
        F["Review findings"] --> G["Record evidence and hand off"]
    end

    B --> C
    E --> F
    F -. "Issue found" .-> C
```

Read it top to bottom: understand the task, make and verify one small change,
then review and hand off evidence. A verified review finding returns to the
change step.

The repository treats generated code as an intermediate result. Completion
requires observable behavior, relevant checks, diff review, and an explicit
record of anything that remains unverified.

| Ad hoc Codex use | Repository workflow |
|---|---|
| Start from a vague request | Define goal, context, constraints, and done conditions |
| Generate a large solution in one pass | Reproduce, change minimally, and verify incrementally |
| Load broad context “just in case” | Route to one lifecycle skill and only relevant specialists |
| Treat passing output as proof | Record commands, results, review findings, and residual risk |
| Add agents because parallelism is available | Delegate only independent, bounded work |

## What the seed measurements show

Skills are not automatically more efficient. In controlled GPT-5.6-sol runs,
the best choice changed with task size:

| Task | Quality result | Most token-efficient variant |
|---|---|---|
| Small backend boundary fix | All three variants passed | No repository skill: 390,144 reported tokens |
| Medium 2048 browser game | All three variants passed | Lean skill v0.4.0: 380,767 reported tokens |

On the game task, the lean `engineering-loop` used **31.2% fewer reported
tokens than v0.2.0** and **54.0% fewer than the no-repository-skill control**.
On the smaller backend fix, the control remained cheapest. This suggests that
lifecycle guidance may be redundant for a bounded fix but useful when a task
spans implementation, testing, review, and evidence handoff.

These are two controlled seed tasks, not universal performance claims. Read the
[backend result](examples/measurements/gpt-5.6-sol-backend-boundary-2026-07-31.md),
the [2048 result](examples/measurements/gpt-5.6-sol-2048-game-2026-07-31.md),
and the [measurement protocol](resources/engineering-loop-measurement.md) before
changing a team workflow.

The [interactive benchmark explorer](https://codex-howto-benchmark.nguyenvantamdk2.chatgpt.site)
turns the six runs into a
task-size toggle, proportional token comparison, run-detail table, method
summary, and visible limitations. Its source and rendered evidence are checked
in CI so the shareable view remains traceable to the repository measurements.
The standalone
[measurement article](resources/articles/do-codex-skills-save-tokens.md)
explains the setup, results, boundary hypothesis, and replication protocol
without requiring a repository click. A complete
[Vietnamese edition](resources/articles/do-codex-skills-save-tokens.vi.md)
preserves the same measurements and limitations for local publication.

## Measure workflows instead of collecting them

Established community projects already provide strong engineering methods.
[`mattpocock/skills`](https://github.com/mattpocock/skills) emphasizes small,
composable workflows for real engineering.
[`obra/superpowers`](https://github.com/obra/superpowers) provides a more
prescriptive design, planning, TDD, review, and verification lifecycle.

This repository does not vendor or rename those catalogs. It provides
[comparison profiles](resources/third-party-workflow-profiles.md) and a common
[measured task receipt](examples/templates/measured-task-receipt.md) so teams
can compare no skill, the lean Codex loop, and selected third-party workflows
under the same task contract.

The useful question is not “which catalog is best?” It is “which minimum
workflow improves acceptance, evidence, or safety enough to justify its
context, checkpoints, time, and total tokens for this task class?”

## Five-minute engineering demo

Use the dependency-free [engineering playground](labs/engineering-playground/README.md)
to demonstrate a complete backend defect loop safely:

```bash
demo_root="$(mktemp -d)"
cp -R labs/engineering-playground "$demo_root/playground"
mkdir -p "$demo_root/playground/.agents/skills"
cp -R skills/engineering-loop "$demo_root/playground/.agents/skills/"
cd "$demo_root/playground"
git init
```

Start Codex in that directory and ask:

```text
$engineering-loop Inspect the inventory reservation contract, reproduce one
uncovered input-boundary defect, add the smallest regression test, implement
the fix, run the required checks, and review the final diff. Work only in this
disposable playground.
```

Watch for four proof points: a failing regression before the fix, a small
implementation diff, passing focused checks, and a final evidence report.
Then use the
[measurement protocol](resources/engineering-loop-measurement.md) to compare
no-skill, full-skill, and lean-skill runs without treating one demo as proof.
For a larger implementation exercise, use the
[dependency-free 2048 benchmark](labs/2048-game-benchmark/README.md) and inspect
the [GPT-5.6-sol seed measurement](examples/measurements/gpt-5.6-sol-2048-game-2026-07-31.md).
To measure a genuinely partitioned large task, compare one agent with bounded
backend/frontend ownership in the
[incident-response orchestration benchmark](labs/incident-response-benchmark/README.md).
The standalone
[multi-agent decision article](resources/articles/when-should-codex-use-multiple-agents.md)
explains the ownership rule, smoke evidence, controller contract, invalid
claims, and replication protocol in a shareable format.
Use [PRESENTING.md](PRESENTING.md) for a 15-minute talk track, demo checklist,
and copy-ready announcement.

## Make Codex know-how compound

The [Codex Living Wiki](knowledge/README.md) turns repeated research into a
reviewed, source-grounded knowledge layer:

```mermaid
flowchart LR
    A["Official docs and engineering evidence"] --> B["Living wiki"]
    B --> C["Query with citations"]
    B --> D["Lint drift and provenance"]
    B --> E["Promote through a reviewed PR"]
    E --> F["Module, skill, rule, or check"]
```

It adapts
[Karpathy's LLM Wiki idea](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f)
for Codex engineering. External source bodies stay out of Git by default,
deterministic lint checks mechanical integrity, and factual changes remain
human-reviewed.

Try a read-only query:

```text
$maintain-codex-wiki What does this repository know about orchestration
efficiency? Cite wiki pages, separate evidence from recommendation, and do not
modify files.
```

The wiki starts with Markdown and repository search—no database, embeddings, or
MCP service until measured retrieval quality justifies them.

## Why this repository exists

Official documentation is the source of truth for product behavior. This
repository turns that product surface into a practical, runnable curriculum for
software engineers.

You will learn how to:

- give Codex enough context without flooding the conversation;
- encode repository conventions in `AGENTS.md`;
- turn repeated frontend, backend, DevOps, testing, review, and security work into skills;
- connect external systems through MCP;
- choose safe sandbox and approval settings;
- delegate bounded work to specialized agents;
- orchestrate parallel work without creating edit conflicts;
- reduce wasted context, retries, and unnecessary token use;
- compile evolving Codex know-how into a review-first living wiki;
- automate stable workflows only after they are reliable interactively.

## What is included

- **14 progressive modules** covering safety, prompting, `AGENTS.md`, skills,
  MCP, subagents, orchestration, context efficiency, automation, and
  living knowledge maintenance.
- **9 installable skills** covering the end-to-end engineering
  loop, frontend, backend, DevOps, testing, code review, security review, and
  orchestration, plus review-first knowledge maintenance and an explicit
  router kept as an educational example.
- **A living maintainer wiki** with registered provenance, deterministic
  linting, review gates, and a measured promotion path into the curriculum.
- **Copy-ready examples** for project configuration, custom agents, prompts,
  engineering specifications, dependency-aware tickets, handoffs, hooks, MCP,
  and local plugins.
- **A dependency-free playground** with seeded defects for practicing the full
  implement–test–review loop safely.

## Who this is for

- **Beginners** who can open Codex but are unsure how to structure a real task.
- **Working engineers** who want repeatable workflows for production repositories.
- **Tech leads** who want shared agent instructions and review standards.
- **Platform teams** building skills, plugins, MCP integrations, and CI automation.

## Choose your route

| Goal | Start here |
|---|---|
| Learn safe Codex fundamentals | [Track A · Safe beginner](LEARNING-ROADMAP.md#track-a-safe-beginner) |
| Build and review application code | [Track B · Application engineer](LEARNING-ROADMAP.md#track-b-application-engineer) |
| Work with delivery and infrastructure | [Track C · Platform and DevOps engineer](LEARNING-ROADMAP.md#track-c-platform-and-devops-engineer) |
| Coordinate subagents efficiently | [Track D · Agent orchestrator](LEARNING-ROADMAP.md#track-d-agent-orchestrator) |
| Maintain evolving Codex know-how | [Track E · Knowledge maintainer](LEARNING-ROADMAP.md#track-e-knowledge-maintainer) |
| Learn by fixing a small project | [Engineering playground](labs/engineering-playground/README.md) |

## Learning path

| Stage | Module | Outcome | Time |
|---|---|---|---:|
| Foundation | [00 · Mental model](modules/00-mental-model/README.md) | Choose the right Codex surface and task shape | 25 min |
| Foundation | [01 · Sandbox and approvals](modules/01-sandbox-and-approvals/README.md) | Set safe autonomy boundaries before the first write | 45 min |
| Foundation | [02 · CLI and surfaces](modules/02-cli-and-surfaces/README.md) | Install, authenticate, navigate, and inspect safely | 35 min |
| Foundation | [03 · Prompts and plans](modules/03-prompts-and-plans/README.md) | Write scoped prompts with observable completion criteria | 40 min |
| Foundation | [04 · AGENTS.md](modules/04-agents-md/README.md) | Make repository guidance durable and local | 45 min |
| Engineering | [05 · Engineering skills](modules/05-engineering-skills/README.md) | Build and install reusable engineering workflows | 60 min |
| Engineering | [06 · MCP and tools](modules/06-mcp-and-tools/README.md) | Add live data and actions without bloating instructions | 45 min |
| Engineering | [07 · Testing and review](modules/07-testing-and-review/README.md) | Close the implementation–verification–review loop | 55 min |
| Scale | [08 · Subagents](modules/08-subagents/README.md) | Delegate narrow, independent work | 50 min |
| Scale | [09 · Orchestration](modules/09-orchestration/README.md) | Coordinate parallel agents with clear ownership | 70 min |
| Scale | [10 · Context and token efficiency](modules/10-context-and-token-efficiency/README.md) | Reduce context pollution and expensive retries | 50 min |
| Scale | [11 · Automation, plugins, and hooks](modules/11-automation-plugins-hooks/README.md) | Package and automate stable workflows | 60 min |
| Operations | [12 · Troubleshooting](modules/12-troubleshooting/README.md) | Diagnose failures by layer instead of guessing | 35 min |
| Operations | [13 · Living Codex wiki](modules/13-living-codex-wiki/README.md) | Compile, verify, and promote evolving know-how | 55 min |

Full path: roughly **10–11 hours**. Start with modules 00–03, then follow the
shortest track that matches your work.

## Five-minute safe start

1. Install Codex using the [official quickstart](https://developers.openai.com/codex/quickstart).
2. Open a small, version-controlled repository.
3. Ask Codex:

   ```text
   Goal: explain how this repository is built and tested.
   Context: inspect the root configuration and contributor docs.
   Constraints: read only; do not install dependencies or change files.
   Done when: return the exact build, test, lint, and type-check commands,
   and cite the files that define them.
   ```

4. Review the result.
5. Generate a starter `AGENTS.md` with `/init`, then replace generic text with verified commands.

## Engineering skill catalog

Start with the model, the task contract, and repository guidance. Add one
focused skill only when it improves a measured engineering outcome or supplies
non-generic workflow, safety, policy, or tool knowledge. Use the
[model-adaptive skill guide](resources/model-adaptive-skills.md) and
[three-way ablation protocol](resources/engineering-loop-measurement.md) before
standardizing a skill for a team.

This repository includes nine installable starter skills:

| Skill | Purpose |
|---|---|
| [`engineering-loop`](skills/engineering-loop/SKILL.md) | Drive a change through baseline, implementation, testing, review, and evidence |
| [`build-frontend`](skills/build-frontend/SKILL.md) | Implement accessible UI changes with visual and behavioral verification |
| [`build-backend`](skills/build-backend/SKILL.md) | Change APIs, services, persistence, and contracts safely |
| [`operate-devops`](skills/operate-devops/SKILL.md) | Modify delivery and infrastructure with rollback-aware validation |
| [`review-code`](skills/review-code/SKILL.md) | Find consequential defects, regressions, and missing tests |
| [`test-software`](skills/test-software/SKILL.md) | Design risk-based tests and implement the highest-value coverage |
| [`review-security`](skills/review-security/SKILL.md) | Trace trust boundaries and report exploitable security risks |
| [`orchestrate-engineering`](skills/orchestrate-engineering/SKILL.md) | Coordinate bounded agents while protecting context and avoiding edit conflicts |
| [`maintain-codex-wiki`](skills/maintain-codex-wiki/SKILL.md) | Query, capture, ingest, archive, lint, and promote review-first Codex knowledge |

The [quick start](#try-the-engineering-loop) installs `engineering-loop`.
Install the Living Wiki maintainer through the same
[open agent skills ecosystem](https://skills.sh/phelan164/codex-howto):

```bash
npx skills add Phelan164/codex-howto --skill maintain-codex-wiki -g -a codex -y
```

The flagship skills also have independently scanned SkillStore pages:
[Engineering Loop](https://skillstore.io/skills/phelan164-engineering-loop) and
[Maintain Codex Wiki](https://skillstore.io/skills/phelan164-maintain-codex-wiki).

List all nine skills without installing:

```bash
npx skills add Phelan164/codex-howto --list
```

Alternatively, inspect and copy a skill into `.agents/skills/` for one project
or `~/.agents/skills/` for personal reuse:

```bash
mkdir -p .agents/skills
cp -R /path/to/codex-howto/skills/review-code .agents/skills/
```

Inspect every skill before installing it, then start a new Codex task and invoke
it explicitly:

```text
$review-code Review this branch against main. Lead with consequential findings
and list checks you could not run.
```

The explicit-only
[`choose-engineering-flow`](examples/skills/choose-engineering-flow/SKILL.md)
router remains an educational example, not a recommended runtime dependency.
Clear skill descriptions should normally let Codex select the relevant
workflow without spending another turn on routing. The orchestrator remains
explicit-only because accidental activation adds coordination overhead.
`maintain-codex-wiki` is also explicit-only because capture, ingest, archive,
and promotion can change shared factual guidance.

For a complete local develop–test–review cycle, install `engineering-loop` and
start with:

```text
$engineering-loop Implement this change end to end. Continue through focused
tests, required checks, diff review, and verified fixes. Stop on missing
authority or an ambiguous test environment.
```

## The orchestration rule

Use one agent by default. Add agents only when the work has independent, bounded parts.

```mermaid
flowchart TD
    A["New task"] --> B{"Can one agent finish it clearly?"}
    B -- Yes --> C["Use one agent"]
    B -- No --> D{"Are parts independent?"}
    D -- No --> E["Plan sequential stages"]
    D -- Yes --> F{"Mostly read-heavy?"}
    F -- Yes --> G["Delegate in parallel"]
    F -- No --> H["Assign exclusive file ownership or run sequentially"]
    G --> I["Return concise evidence summaries"]
    H --> I
    I --> J["Main agent integrates and verifies"]
```

Parallel agents often improve elapsed time and protect the main thread from noisy logs, but they normally use **more total tokens**. The efficiency target is fewer failed loops and cleaner context, not the maximum number of agents.

Want configurable models for delegated work? Try the experimental
[subagent model-routing hooks](examples/hooks/model-routing/README.md): personal
easy/medium/difficult tiers, preserved explicit choices, reviewer minimums, and
bounded escalation. Setup and runtime verification are required; this does not
switch the main app model or establish token savings.

For optional **main-turn routing in the CLI**, see the
[experimental JEV Router pilot](resources/jev-router-pilot.md). It covers
third-party prompt sharing, compatibility checks, and a quality-first comparison
of time and usage. No installation is required for this guide, and no savings
have been established by this pilot.

## Repository map

```text
codex-howto/
├── .github/                 # Validation workflow and PR template
├── .codex-plugin/           # Plugin manifest over the existing skill catalog
├── modules/                 # Progressive tutorials and labs
├── skills/                  # Installable engineering skills
├── knowledge/               # Review-first maintainer evidence wiki
├── labs/
│   └── engineering-playground/ # Self-contained practice project
├── examples/
│   ├── agents/              # Project-scoped custom agent definitions
│   ├── config/              # Conservative Codex configuration
│   ├── prompts/             # Copy-ready task and orchestration prompts
│   └── AGENTS.md            # Starter repository guidance
├── resources/               # Checklists and comparison material
└── scripts/validate_repo.py # Offline structural validation
```

See [CATALOG.md](CATALOG.md) for the complete index and [LEARNING-ROADMAP.md](LEARNING-ROADMAP.md) for suggested tracks.

For a dependency-free end-to-end exercise, copy the
[engineering playground](labs/engineering-playground/README.md) to a disposable
directory and practice backend, frontend, DevOps, testing, review, security, and
orchestration workflows against its seeded defects.

## Source policy

- Product behavior and configuration claims must link to official OpenAI documentation.
- Community examples must be labeled as community material.
- Version-sensitive examples should include a verification date.
- Secrets, production credentials, and destructive defaults are never included.
- Marketing claims such as “10x productivity” are intentionally avoided.

## Inspiration and related work

The progressive-module idea was inspired by [luongnv89/claude-howto](https://github.com/luongnv89/claude-howto). This repository is an original Codex-focused curriculum and does not copy its tutorial text or templates.

The skill-system refinements were inspired by the original
[mattpocock/skills](https://github.com/mattpocock/skills) repository. Its
invocation, routing, debugging, and review ideas were adapted to Codex without
copying its skills.

The workflow-calibration profiles also study
[obra/superpowers](https://github.com/obra/superpowers), particularly its
design gates, worktree isolation, verification discipline, staged review, and
skill-behavior testing. `codex-howto` links to both MIT-licensed upstream
projects rather than vendoring their catalogs.

Bounded autonomous-loop controls were informed by
[affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code),
especially its plan-build-judge, evaluation, context-budget, and cost-tracking
workflows. The Codex adaptation remains optional and is measured as a focused
component rather than importing the full harness.

The living-wiki pattern was inspired by
[Karpathy's LLM Wiki idea](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f).
The review-first Codex adaptation also studies
[Astro-Han/karpathy-llm-wiki](https://github.com/Astro-Han/karpathy-llm-wiki),
[lucasastorian/llmwiki](https://github.com/lucasastorian/llmwiki), and
[atomicstrata/llm-wiki-compiler](https://github.com/atomicstrata/llm-wiki-compiler).
External source bodies are not copied into this repository by default.

Useful related community projects:

- [freestylefly/CodexGuide](https://github.com/freestylefly/CodexGuide)
- [geekjourneyx/awesome-codex-guide](https://github.com/geekjourneyx/awesome-codex-guide)
- [bozhouDev/codex-orange-book](https://github.com/bozhouDev/codex-orange-book)
- [RoggeOhta/awesome-codex-cli](https://github.com/RoggeOhta/awesome-codex-cli)
- [ComposioHQ/awesome-codex-skills](https://github.com/ComposioHQ/awesome-codex-skills)
- [VoltAgent/awesome-codex-subagents](https://github.com/VoltAgent/awesome-codex-subagents)

The authoritative upstream implementation is [openai/codex](https://github.com/openai/codex).

## Contributing

Contributions are welcome. Start with [CONTRIBUTING.md](CONTRIBUTING.md). New
tutorials should include a concrete outcome, a safe exercise, a verification
step, and official sources.

If the guide is useful, choose the action that creates the most value:

- try the playground and report a reproducible gap;
- [submit an anonymized benchmark replication](https://github.com/Phelan164/codex-howto/issues/new?template=benchmark-replication.yml);
- [test the Living Wiki against normal repository search](https://github.com/Phelan164/codex-howto/issues/16);
- [fork it into a tested stack, team, translation, or benchmark edition](resources/fork-an-edition.md);
- share it with one relevant developer community; or
- star it so you can find it again.

Use the [community guide](COMMUNITY.md) for responsible participation and the
[launch kit](resources/community-launch-kit.md) for audience-specific
presentation material.

## License and trademarks

Released under the [MIT License](LICENSE). “OpenAI” and “Codex” are trademarks
of their respective owners. This is an independent community project and is not
endorsed by OpenAI or Anthropic.

© Phelan164 · MIT · hashgraph-online/awesome-codex-plugins

Similar plugins

All plugins for Agent setup: memory, context, orchestration →
howto-docs existential-birds The howto-docs skill shapes task-focused how-to guides with prerequisites, actionable steps, result checks, and troubleshooting for readers who already know the product. CX Codex +1 135installs ub-mode unclebob The ub-mode skill for Claude Code helps developers structure code changes. It guides the development process by following the principles of "First Make it Work, Then Make it Right, Then Follow Practice." CX Codex +1 930installs methodology-advisor FlorianBruniaux The methodology-advisor command for Claude Code and Codex reads the codebase and asks three questions to recommend an AI-development methodology stack. Run it at the start of a project, before choosing a workflow. CX Codex +1 ★ 6,529repo stars discernment-nudge official anthropics discernment-nudge — a plugin for Claude Code and Claude.ai that appends two or three short questions after a substantive answer. Helps check key facts, probe the reasoning, and spot missing context. ★ 198,522repo stars example-skills official anthropics example-skills — a plugin for Claude Code and Claude.ai with a set of sample skills. Demonstrates how to build skills, MCP servers, artifacts, web tests, and internal communication tools. ★ 198,522repo stars impeccable pbakaus impeccable — a Claude Code plugin that gives the agent a designer's vocabulary and 24 commands for working with interfaces. Kick it off at any stage, from gathering product context to the final polish pass. ★ 114,575repo stars superpowers obra superpowers — a plugin for Claude Code and Codex that teaches the agent a complete methodology: requirements gathering, design, TDD, and subagent-driven development. Triggers automatically when you start building something new. CX Codex ★ 323,788repo stars ponytail DietrichGebert ponytail is a Claude Code plugin that steers coding tasks toward short, practical solutions. Its review command checks related code for bugs, security issues, and missing tests. ★ 196,420repo stars

From the same set391

The whole set →
codex-quota-title codex-quota-title shows remaining Codex quota and reset time in the Codex Desktop window title on Windows. The original title stays visible. CX Codex ★ 1,596repo stars codex-quota-optimizer codex-quota-optimizer is a Claude Code plugin that routes tasks to an adequate model and narrows repository context. It also applies layered checks. CX Codex ★ 1,596repo stars codex-process-jobs codex-process-jobs runs local builds, tests, and benchmarks as detached background processes on macOS and Linux, keeping status and logs after the agent turn ends. CX Codex ★ 1,596repo stars codex-multi-auth codex-multi-auth is a Claude Code and Codex plugin for managing ChatGPT accounts used by the official Codex CLI. It switches accounts and checks their health. CX Codex ★ 1,596repo stars codex-auto-resume codex-auto-resume monitors Codex usage limits on Windows, waits for the reset time, and automatically resumes the exact same conversation via codex queue. Built for overnight tasks. CX Codex ★ 1,596repo stars codex-agents-workflow codex-agents-workflow is a Claude Code plugin for building and running reusable agent workflows. It supports workflow setup with configurable roles and providers, plus recoverable runs. CX Codex ★ 1,596repo stars ateam ateam turns Claude into a six-role team: researcher, PM, architect, dev, QA and reviewer, joined into a configurable pipeline. CX Codex ★ 1,596repo stars codetruss The codetruss plugin for Claude Code and Codex sets agent file boundaries, runs local analyzers on code changes, and creates signed review receipts. CX Codex ★ 1,596repo stars

Project sponsors

Companies that keep this analytics open