Your AI Skills Should Belong to You — Not ChatGPT, Claude, or Gemini

I moved my reusable AI workflows into GitHub so the skill belongs to me rather than to one AI platform.

Series/category: Practical AI Systems
Estimated reading time: 6 minutes

I recently realized something about the way I was using AI.

I was spending quite a bit of time building useful workflows inside ChatGPT. I would refine the instructions, add context, test the output, correct what didn’t work, and slowly turn that process into something reliable.

Essentially, I was teaching the AI how I like a particular job to be done.

And then a question hit me:

Why should that knowledge belong to ChatGPT?

What happens when I want to use Claude tomorrow? Or Gemini? Do I recreate the whole thing again?

That question eventually led me to move my AI skills into GitHub and start treating them very differently: not as features of an AI platform, but as something I own.

First, What Do I Mean by a “Skill”?

Think about people you have worked with.

There might be one person who is exceptionally good at taking a broad topic, diving into it, finding useful information, and producing solid research. Then there might be someone else who can take that research and turn it into a clear, persuasive presentation.

Those are two different skills. Research is a skill. Presentation is another skill.

A skill is something you develop through experience, practice and repetition. Once you have it, you can apply it to different situations.

That idea translates surprisingly well to AI.

Instead of repeatedly telling an AI:

Research this topic.
Structure it like this.
Don’t make it sound too formal.
Check these sources.
Use this writing style.
Format the final output this way.

…you can package that knowledge into a reusable set of instructions.

Now the AI isn’t just responding to one prompt. It has a process.

That is how I think about an AI skill.

The Problem Starts When the Skill Becomes Good

Initially, I was perfectly happy creating skills inside ChatGPT.

Take my blogging workflow. I don’t simply ask AI to “write a blog about this topic.” I have developed a much more deliberate process.

I first identify ideas from things I am actually learning, testing or discussing. Then there is research. Then the article needs structure. Then it needs to sound like me rather than like a generic AI article. Then I think about where screenshots, diagrams or technical visuals would actually help. Finally, there are checks before anything goes to WordPress.

Over time I turned those individual steps into reusable skills and connected them into what I call my Personal Blog Pipeline.

Research → Structure → Writing → Visuals → Publishing

That is much more valuable to me than one clever prompt. Because every time I improve the workflow, future articles benefit from that improvement.

But then I ran into the obvious problem: I had built all of this around one AI environment.

What Happens When I Want to Use Claude or Gemini?

Suppose tomorrow I discover that Claude works better for a particular writing task. Or Gemini has something useful for another part of my workflow.

My blogging process hasn’t suddenly changed. My preferences haven’t changed. The things I have learned about creating a good article haven’t changed.

So why should I have to rebuild the skill?

That’s where the architecture started feeling wrong to me.

I didn’t want one ChatGPT version, one Claude version and one Gemini version—with each one slowly becoming different as I updated them separately.

I wanted one master version. Every AI platform should work from that.

So I Put My Skills on GitHub

The solution I started experimenting with was surprisingly simple.

I moved the canonical versions of my skills into a GitHub repository.

At the center of each skill is essentially a Markdown file describing how that skill should work.

.agents/
└── skills/
    ├── personal-writing/
    │   └── SKILL.md
    ├── personal-content/
    │   └── SKILL.md
    ├── blog-image-creator/
    │   └── SKILL.md
    └── personal-blog-pipeline/
        └── SKILL.md

Now GitHub becomes the single source of truth.

Instead of improving “the ChatGPT skill”, I improve my skill. The platforms become consumers of it.

That distinction sounds small, but I think it changes the way we should think about personal AI workflows.

My Personal Writing Skill Is a Good Example

Imagine I improve the writing skill after noticing something I don’t like in a few articles.

Maybe my posts are becoming too verbose. Maybe I notice too many generic introductions. Maybe technical explanations need more concrete examples.

I can change the instructions once in the canonical skill.

That improvement now belongs to the skill itself rather than being buried somewhere inside a conversation with one AI product.

The same principle applies to far more than blogging.

• researching a topic;
• reviewing code;
• preparing presentations;
• analyzing job descriptions;
• writing documentation;
• creating social media content;
• planning projects;
• evaluating product ideas.

Once a workflow becomes valuable enough, I think it deserves to exist independently from the AI application currently running it.

Portable Instructions Don’t Mean Every AI Is Identical

There is an important distinction here.

When I say the skill is portable, I don’t mean ChatGPT, Claude and Gemini suddenly become interchangeable. They aren’t.

A skill might describe a workflow such as:

Search my previous discussions, identify useful content ideas, research the best one, write the article using my writing style, create the required visuals and prepare it for publishing.

The workflow can be portable. But the environment executing it still matters.

One platform might have access to a particular connector. Another might have different file access. Another might handle tools or external services differently. Permissions will differ. Capabilities will differ. Even the way the models interpret the same instructions can differ.

So I don’t think the goal should be to make every platform behave identically.

The goal is to separate the knowledge of how the work should be done from the platform executing the work.

That is a much more useful form of portability.

GitHub Also Solves Another Problem: Skills Evolve

My skills aren’t finished products. They change constantly.

Every time something goes wrong, I learn something. Sometimes I add a rule. Sometimes I remove unnecessary instructions. Sometimes I break one giant skill into smaller skills. Sometimes two skills start working together.

That makes GitHub a natural home for them because I get something AI chat interfaces aren’t designed to provide particularly well: version history.

I can see what changed. I can roll something back. I can experiment without destroying the stable version. I can eventually test skills. And, importantly, I can make the same updated version available to multiple AI systems.

I’m effectively starting to treat my AI workflows a little more like software.

The Bigger Idea Isn’t Really GitHub

GitHub is just the implementation I chose.

The more important idea is this:

Your skill should not be hard-wired to ChatGPT, Gemini or Claude. It belongs to you.

We are putting more and more effort into teaching AI systems how we work.

We’re defining our writing style, our research process, our decision-making frameworks, our preferences, our business workflows, our coding conventions and our content creation process.

That accumulated knowledge is becoming valuable.

If all of it exists only inside one product, moving to another AI means leaving some of that work behind.

I don’t think that is how personal AI systems should evolve.

The model should be replaceable. Your workflows shouldn’t be.

Build Once. Improve Over Time. Reuse Everywhere.

This is still something I’m experimenting with.

There are rough edges. Different AI platforms support skills differently, and some parts still need adapters or platform-specific configuration.

But the direction makes sense to me.

I want to be able to create a skill once. Use it. Notice what doesn’t work. Improve it. And have that improvement follow me wherever I choose to use AI next.

Today that might be ChatGPT. Tomorrow it might be Claude. For another task it might be Gemini or something completely different.

The AI platform can change.

The skill remains mine.

And I think that is going to become increasingly important as we start building more serious workflows around AI.

Watch the Video

I walk through the idea and the setup in this video: