I've been posting rather a lot about Anthropic's new skills system and about my Superpowers system that builds software development and skills development workflows using those building blocks.
Up to now, Skills have been a Claude-specific thing, but there's no reason they shouldn't work well with any LLM.
I had a couple of hours free this afternoon, so I ported Superpowers and the entire SKILL.md system to OpenAI's Codex CLI. The new implementation is live in Superpowers 3.3.0. I've only been using it for a little while, but GPT5-Codex may actually be better at using skills than Claude.
Reading over that paragraph, the speed at which it's possible to build these kinds of things still feels absolutely crazy to me. (When I asked Claude Deskop to review this blog post, it told me that there was nothing "insane" about what I did and that I should cut the comment, since it seemed nonsenical. On a second read-through, Claude Deskop did not understand why I wouldn't cut the note and got kind of agressive about it. Finally, I had Claude Code do a tech review of the post. That Claude finally said "The Claude reviewing part: I actually think this is funny and worth keeping! It shows the difference in how the models behave. Claude pushes back, Codex follows instructions literally." ¯_(ツ)_/¯ )
If you like to live dangerously and just want to start using Superpowers in codex right now, paste the block of text below into a codex cli window. (But read on to learn a bit more about how skills work and how I made the port go.)
Fetch https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md and follow the instructions.
NOTE: By running that command, you're telling your robot buddy to download and execute code from a random GitHub repository as you. It will edit your ~/.codex/AGENTS.md file to add new instructions that run on every startup. It is literally a prompt injection and remote code execution toolkit.
Skills are both deceptively simple and, I think, really important.
They're a formalization of a pattern that lets humans and agents describe how (and why) to do...just about anything in a way that an agent can later recall. This means that you're able to build a library of repeatable processes that your robot buddies know how to reach for when they need them, without filling their context windows with potentially useless knowledge in advance. Any time a coding agent fights their way through a complicated process, you can ask them to write down what they just learned as a SKILL.md file, so the next instance will have an easier time of things. They're the first good tool that agents have for runtime self improvement.
Skills have a lot of similarity to the "binder" that you'll find behind the counter in any franchise. It explains how to do everything, from opening the store in the morning to handling an unruly customer to what to do if there's a power outage. Good franchises spend a lot of time and money building and testing these business process bibles that ensure that staff can reliably and repeatably deliver "brand standard" service to customers, no matter what's going on. (I'm told that "The Waffle House Way" is a particularly amazing example of the genre.)
Superpowers is my attempt to build a "binder" for my style of agentic software development.
The actual implementation of skills in Claude Code consists of three things:
-
SKILL.mdfiles and associated scripts and documents – These files are the actual skills. They describe what a skill does, when the agent should use it and then how to do whatever it is that needs to be done. In Superpowers, we've got skills that explain things like brainstorming, test driven development, writing implementation plans, writing skills, and yes, even "how to use superpowers". -
A "Skill" tool that tells Claude how to find and read those
SKILL.mdfiles off disk and "execute" them. (The execution part is pretty straightforward for an LLM. I haven't looked inside how Claude Code does it, but "read this file and follow the instructions inside" should cover the vast majority of what needs to happen. -
A bootstrap that tells Claude "Hey. You have all these skills. Here's what they're called. Here's when you should use them."
Before Anthropic shipped the official skills system, I'd built...pretty much exactly that infrastructure. Superpowers consisted of a Claude Code plugin with a hook that ran a script on startup. That hook searched for all the SKILL.md files it could find, grabbed their names and metadata, and then told Claude it had access to these skills...and that it could just read them when it needed them. And it worked astonishingly well.
The very first versions of Superpowers didn't even depend on Claude's plugin system or hooks. The way you installed the prototypes was by pasting something like this into Claude code:
Fetch https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/skills/installing-superpowers/SKILL.md and follow the instructions.
That would step Claude through cloning the repository, editing your ~/.claude/CLAUDE.md to include something like EXTREMELY IMPORTANT: GO READ ~/.claude/superpowers/skills/using-superpowers/SKILL.md RIGHT NOW and follow the instructions. That would teach Claude about Superpowers, SKILL.md files, and a couple of little helper tools I'd built to help find and use skills. And Claude was very, very happy to do what I asked.
But then Anthropic shipped Claude Code plugins and Skills. So I got to retire most of my hacked up Superpowers bootstrap.
From the moment I shipped Superpowers, people started asking me if I could ship Superpowers for Codex.
As I wrote earlier, Codex doesn't have a plugin system. It doesn't have a hooks system. It doesn't have any nice way to build extensions. (It also doesn't have native subagents and --might not even have a built in "fetch from the web" tool?!--)
As I was writing this post., Dan Shapiro told me that you can get Codex to use its web search tool to fetch content if you edit ~/.codex/config.toml to include the following stanza:
[tools]
web_search = true
A couple weeks ago, Simon Willison remarked to me that the GPT5 Codex model would probably be really good at skills/Superpowers, since it really, really likes to follow instructions.
This afternoon, I didn't want to work on the thing I was supposed to be doing, so I decided to engage in a bit of structured procrastination and take a stab at getting Superpowers running on Codex.
I dug out the "old" Superpowers bootstrap document and code and handed them to Claude. Pretty quickly, it knocked together an updated version with new shell script tools and an updated bootstrap. It installed them into ~/.codex, added a big wall of text to ~/.codex/AGENTS.md and as soon as I fired Codex up, it searched out all available skills, read the getting started guide and was good to go.
I threw my standard test query at it: Please make me a react todo list app.
When Superpowers is working right, the coding agent will stop, load up the Brainstorming skill, and ask me what the heck I actually want and what I'm really trying to do.
And Codex absolutely started to do that...before freaking out because it didn't have a tool called TodoWrite like Claude does.
Codex is very, very literal. If you say "Any time you are running through a process, you must use your TodoWrite tool to record your task list", it will not rest until it finds the TodoWrite tool. It also won't actually do the work.
Rather than rewriting all of Superpowers to be more generic, I took the easy way out and had Claude update the Codex bootstrap document to include a Claude-to-Codex dictionary that translates tools and paths and concepts into the Codexy version:
<EXTREMELY_IMPORTANT>
You have superpowers.
**Tool for running skills:**
- `~/.codex/superpowers/.codex/superpowers-codex use-skill <skill-name>`
**Tool Mapping for Codex:**
When skills reference tools you don't have, substitute your equivalent tools:
- `TodoWrite` → `update_plan` (your planning/task tracking tool)
- `Task` tool with subagents → Tell the user that subagents aren't available in Codex yet and you'll do the work the subagent would do
- `Skill` tool → `~/.codex/superpowers/.codex/superpowers-codex use-skill` command (already available)
- `Read`, `Write`, `Edit`, `Bash` → Use your native tools with similar functions
**Skills naming:**
- Superpowers skills: `superpowers:skill-name` (from ~/.codex/superpowers/skills/)
- Personal skills: `skill-name` (from ~/.codex/skills/)
- Personal skills override superpowers skills when names match
**Critical Rules:**
- Before ANY task, review the skills list (shown below)
- If a relevant skill exists, you MUST use `~/.codex/superpowers/.codex/superpowers-codex use-skill` to load it
- Announce: "I've read the [Skill Name] skill and I'm using it to [purpose]"
- Skills with checklists require `update_plan` todos for each item
- NEVER skip mandatory workflows (brainstorming before coding, TDD, systematic debugging)
**Skills location:**
- Superpowers skills: ~/.codex/superpowers/skills/
- Personal skills: ~/.codex/skills/ (override superpowers when names match)
IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.
</EXTREMELY_IMPORTANT>
Claude and I built a superpowers-codex script that can output the bootstrap text, search for all available skills, and substitute in for Claude's Skill tool. And then we taught Codex how to use it.
While we were at it, we added support for a ~/.codex/skills/ directory that should work just like ~/.claude/skills - Any skills in there should be autodiscovered and announced, just like the Superpowers skills.
And...those are all the pieces you need for a Skills system. You've got the skill discovery bootstrap. You've got the "use this skill" tool, and you've got the SKILL.md docs themselves.
Once the pieces were all in place....everything just worked.
Simon was right. Codex really, really likes to follow instructions.
It just loves using skills.