People keep fighting about which provider is better,
Code or Codex. A few months ago, Claude Code was everyone's darling. But in the past few weeks, Codex has been emerging and many people have been shifting over. And, honestly, I don't see this trend changing anytime soon, and wouldn't be surprised if in another few weeks, people start flocking back to Cloud Code. But here's the part that nobody's talking about. When it comes to skills, both providers can handle them, but the way they're designed, used, and executed are pretty different. You'll end up having to recycle and recreate skills over and over again. So the point of this video is to equip you with one single skill that you can use as a universal adapter to convert a Cloud Code skill to a Codec skill and vice versa. So by the end of this video, I'm gonna give you a skill and slash command that you can use to maintain your nimbleness in this ever changing space. If that sounds interesting, then let's jump in. So our goal here is very simple. We wanna be able to create and convert any skill to have it work in both Codex and Claude code at the same time. So it should look something like this, where you can go into Claude code right here, then enter something like Polyskill,
which is the name of our skill that I'll be giving you today, which will be our main converter.
If you pop into Codex through the CLI as well, you'll be able to see it here as well.
And then if you wanna be able to use it through Claude desktop or you wanna use it through the Codex app, then if you pop over there, you should be able to see this here as well. And the best part of this is that if you have the right skill and process,
this is as simple as just executing the exact same skill in two different folders and making sure it shows up and renders correctly. Now although the overall concept of a skill is the same between OpenAI and Anthropic,
when it comes to the mechanics and nuts and bolts, there are some nuances.
So in Claude code, you can do something more nuanced where you can actually drop a terminal command in the middle of a skill and it will know how and when to execute it. While you can execute something similar in codex, it wouldn't be in the exact same way from a structure standpoint. And when it comes to codex specifically,
it has this cap on reading all the descriptions of skills
where if you have too many skills, at some point, it might not read the description at all of a particular skill or it will get cut off. So imagine you have a description where you set the context
of when to use the skill, but all of your triggers are at the very end, it might not ever see them. Whereas in Claude Code, it will ram all your descriptions as is as long as they're below a certain character limit within the context window as soon as you start a new session. And on the codec side, we have an extra configuration file that's called a sidecar or another YAML file where it can have more details on what tools and services it should be able to connect to from that particular skill, and this is something that's not present in Cloud Code.
So you have two choices.
Either you constantly maintain and manually convert every single time you wanna do the equivalent of moving houses from OpenAI to Codex, or you do all the work once, get the leverage you need, and use one skill called Polyskill
to take care of everything for you. And by the way, if you like the way I teach and you want access to all of my exclusive content along with our Claude Code Living course where we add one new module every single week that you'll never see on YouTube, then you wanna check out the first link down below from my early adopters community. If you wanna be able to audit what courses exist and what's coming next, we have a link on our about page that you can check out to make sure it's the right decision for you. Alright. Back to the video. But before we jump into the nitty gritty, just in case you're not as familiar with skills or you don't know all of the core components that can comprise a skill, here's your quick TLDR.
So the anatomy of an average agent skill looks like this. You have a skill MD, then you have the name and description in Claude Code. For example, the name is in what's called kebab case.
This has your markdown body walking through all the terminal commands, all the context,
all the order of operations,
and then you have this section that's called scripts.
And in scripts, can have some Python scripts that Claude code uses or executes to get the job done. And then you can have some additional reference files and additional assets that the skill can refer to, and all you'd have to do is just specify this within the skill body itself. When it comes to the cross section of a Claude code skill, it looks like this. So you have the name, description,
which tools are allowed, so which bash commands can execute
using this skill, and at the same time, you can make sure that it needs to ask you permission every single time it uses a skill or whether it should use it automatically. And this is the cross section of a Claude code skill.
So if we zoom in, we have the name, we have the description, which tools, batch commands are allowed to be executed by the skill, and then we have this additional field that's called disable model invocation,
which means do you want the skill to run autonomously
based on Claude Codes' judgment, or do you want it to elicit your approval every single time? And then in the body, like we said, we have this thing that's called dynamic injection and this is the equivalent of being able to run a specific slash command. Now the technical term for this is this exclamation mark is called a bang and this is called a backtick. So a backtick bang is how it would see this terminal command and execute it by proxy. And codexes looks very similar. So if we zoom into here, again, we have name, we have description
where ideally it's better for you to add the trigger at the very beginning so you don't run into that memory issue we mentioned before. And then we have the short description, but notice how it's under the heading metadata.
So this is where the short description goes. And then we have this complimentary file, again called the sidecar
or configuration YAML file that will include things like how it should be displayed
in the interface of the Codex app, which icon it should be represented by, the default prompt, any form of dependencies on tools, any policies,
same thing on the invocation,
but again, it's under a policy heading, etcetera.
So both are functionally able of very similar things, but there are nuances that would have one skill misfire in the other provider. So now that we're on the same page, this is how my Poly skill works.
We have a definition dot markdown file and this is where it identifies
what the skill you're trying to convert looks like, and then it understands how it should be activated and how it should differentiate its body to work for both Claude as well as Codex and create this YAML file if needed for the Codex skill version. And you can think of my skill again as a form of adapter. This is a universal travel adapter, just as an analogy. And behind the scenes, you pretty much have three core pieces. The first piece is what I call the shared structure. It's basically a neutral version of what each skill needs to be irrespective of the specifics of the structure and syntax.
The second piece are the adapters.
You can think of them like cartridges.
If you plug a cartridge in, that tool is now supported by that skill. And if you pull it out, it's no longer available. And the third piece is just the CLI, command line interface.
If you wanna add multiple tools to both providers, then it's as simple as a natural language command. So by some miracle, if Gemini becomes competitive enough to something like Codex or Cloud Code in the near future, and you wanna be able to add this functionality to the adapter, it wouldn't be that hard. All you'd have to do is use your provider of choice to analyze the structure of a Gemini skill, look for the schema, and then find a way to basically abide by it and convert to all three different outputs. I've designed it to be as plug and play as possible. So all you have to do is bring the skill and the associated assets
to the specific skills folder for that particular provider. And once that's done, all you'll have to do is write Polyskill install, and in stage two, you'll officially be able to tap into both run times of both tools. And stage three is as simple as writing Polyskill and saying convert my insert name of specific skill here. And in codex, it would be the dollar sign if you're using the CLI instead of the slash command. All we'd have to do is put the skill in a brand new folder, do Polyskill install like I said. It will build the skill, then install the skill for both providers, and this little squiggly line, this tilde, just means that it's installed globally at the Cloud level and the dot agents level, which is specific to Codex. Then once we have that and scroll down, you could send a prompt as simple as this. So I could do slash Polyskill,
and then this is the name of a skill that I have that basically analyzes YouTube content from other competitors. Then I just tell it go and convert this to work with Codex. If we go to the very bottom here, you'll see it does a full repackaging
of this skill to work in both areas and then as soon as it says that it's landed, then you can navigate to something like the Codex app, go on the three dots right here, click on refresh,
and then you'll be able to see at the very bottom this y compare skill waiting to be used. So let's say you wanna take another skill like the native front end design skill from Cloud Code, we could do the exact same process. I'll go here. I'll do Polyskill
once more,
and then I'll say convert the front end
design skill
to
Codecs.
And then it should be able to go look for the configuration,
look at how it works down to the nth degree, and then replicate that same functionality to work in codecs as well. And I didn't have to pause the video for long and it finished in under ten seconds. So theoretically,
all these assets should be installed. If we go into Codecs, you can see right here, we can't see it off the cuff. But if we do a double click here, we do a refresh,
and we go to the very bottom, we should be able to see, there we go, the front end design skill. It's as easy as doing try and chat,
using it, building whatever you want, and now you have this two way communication between Codex and Cloud Code. You'd have the identical experience in the Codex app where if you use dollar sign Polyskill and you tell it to use one of the Codex native skills, you can bring this to Cloud Code in under a minute and pretty much you can see right here it imported this agent email inbox skill. If we pop into our terminal and we slash clear and we do something like agent
inbox, let's do actually slash agent inbox, agent inbox,
you could see it right here. And the best part of this process is because you can do this seamless two way communication and two way conversion,
anytime you bring any skill in, it could be from Cursor, it could be from Gemini, you could say, want you to take said skill,
adapt it, and disseminate it to both providers so I can use it turnkey out of the box. And that's really it. So we focused on skills, but this could be extended to focus on things like rules,
hooks,
different parts of both systems that you wanna keep in sync at all times so you have the full freedom to go to GPT 5.7
or OPUS five or whatever new model comes out that everyone will side with for a temporary short of time. And this will keep you nimble so that when the day comes and you have codec six or Opus 5.5,
you can switch to the model where you feel that your workflow executes the best. And like I said, you'll be able to grab this entire skill in the second link down below, and you'll be able to adapt it for your specific use cases. But if you wanna be able to access my ongoing updates to this skill along with everything else I maintain for my exclusive community, including our living course where I keep adding brand new modules you'll never see on YouTube, then check the first link down below, and maybe I'll see you in my early adopters community. For the rest of you, if you found this helpful, if you found it novel, then please let me know by leaving a like on the video and a comment if you so choose, and I'll see you in the next one.