DEV Community: AI Sensei LAB

Gemini Gems to Skills: What Changes in November 2026 and How to Move Your Gems Now

AI Sensei LAB — Tue, 20 Oct 2026 01:10:26 +0000

Google's official timeline by account type, what doesn't carry over yet, and the steps to recreate a Gem as a skill before the switch.

Disclosure: this article was drafted and edited with AI tools.

If you've built Gems in Gemini (a writing coach, a meeting-notes formatter, a study helper), Google is replacing them with skills. You may have read that your Gems disappear in November, or that nothing changes until 2027. Both can be true, because Google's dates depend on the type of account you use.

This guide sets out what Google's own help pages say, what won't come across to skills yet, and how to move a Gem yourself if you don't want to wait for the automatic migration.

How this guide was made: every date and step below comes from Google's official Gemini and Workspace help pages and the Workspace Updates blog, checked on October 19, 2026. The steps were not tried hands-on. Google is still updating these pages, and says it will publish full migration details later, so check the linked pages before acting on a date.

The timeline, by account type

Personal Google accounts. Google's Gemini Help page says Gems will "transition to skills" starting in November 2026, and lists November 2026 as when Gems go away for personal accounts. It doesn't give an exact day. Opal and Gems by Google Labs also go away in November.

Work accounts (Workspace business, enterprise and non-profit). Google's admin help page gives this sequence:

Date	What happens
October 13, 2026	Skills start rolling out in the Gemini app. Gems and skills can both be created and used.
November 17, 2026	Gems move to Settings in the Gemini app. Users can still create, edit and use them.
No sooner than March 1, 2027	Gems can no longer be created, edited or used. Remaining Gems migrate automatically to draft skills. Workspace Studio flows with an "Ask a Gem" step stop working.

School accounts (Workspace for Education). The same steps happen no sooner than June 1, 2027, including Gems in Google Classroom and in learning systems connected through Gemini LTI.

So what is November 17? On Google's admin timeline, it's the day Gems move to Settings. It is not the day they stop working for work and school accounts. For personal accounts, Google's consumer page says only "November 2026." If you use a personal account, plan as if your Gems could change at any point in November.

Rollout status (October 19, 2026): Google's Workspace Updates blog says skills in the Gemini app began rolling out on October 13, 2026, with completion expected by mid-November. Skills inside Workspace apps are "Delayed until further notice." If you don't see Skills yet, your account may not have it.

Wait for the automatic migration, or move now?

If you wait, Google says it will automatically recreate your Gems as skills when Gems are removed. According to the admin help page:

Your content comes across. Migrated skills keep their original names, descriptions, custom instructions and uploaded knowledge files ("supported files," in the consumer page's words).
They arrive switched off. They appear as inactive drafts, and you must review and activate each one before you can use or share it.
Sharing settings follow. Drive permissions and sharing settings on a Gem transfer to its skill.
Details are still coming. Google says it will publish full migration details at least 30 days before automated migration starts.

If you move now, you control the result and can check it works before your Gem goes away. Google's admin page recommends this for important Gems: "manually rebuild their critical Gems as skills early."

A reasonable middle path is to move the one or two Gems you rely on most now, and let the automatic migration handle the rest. Either way, you'll need to review each migrated skill.

What doesn't carry over yet

Check these before you depend on a converted skill. The first three points come from Google's Gemini Help page, and the last two from Google's Workspace admin help page (both checked October 19, 2026):

Some built-in tools don't work with skills yet. Google says "most default tools that are available in Gems do not work with skills, including":
- Create video
- Create music
- Canvas
- Deep research
- Guided learning
GitHub files aren't supported in skills "for now."
Sharing skills and adding files from Google Drive are promised "in the coming weeks." Until then, you can't share a skill the way you shared a Gem.
Skills don't sync between the Gemini app and Workspace apps. Gems used in Workspace must be recreated manually in Google Workspace Studio.
Workspace Studio flows can no longer add new "Ask a Gem" steps. Existing flows keep working until the 2027 cut-off, but need rebuilding before then.

If one of your Gems depends on Canvas or Deep Research, keep using it as a Gem while you still can, and recheck Google's page before your account's deadline.

Before you start: a quick inventory

For each Gem, note:

[ ] Its name, description and full instructions (copy them into a document as a backup)
[ ] Any knowledge files attached
[ ] Whether it relies on Canvas, Deep Research, video, music or Guided learning
[ ] Whether you've shared it with anyone
[ ] Whether it's used in a Workspace Studio flow (work and school accounts)
[ ] How often you use it (move the most-used first)

How to recreate a Gem as a skill (Google's steps)

Google's Gemini Help page describes three steps, on a computer at gemini.google.com.

Step 1: Save the Gem's knowledge files

Go to gemini.google.com, open the sidebar and select Gems.
Click Edit next to the Gem you want to move.
If it has files under Knowledge, open each one and click Download. Files have to be downloaded one at a time.
Create a folder named the way the skill will be named: all lowercase with hyphens, for example sample-skill-name. Move the downloaded files into it.
Keep the Gem's tab open.

Step 2: Create the skill and copy the Gem's details

Open gemini.google.com in a new tab.
Open the Skills page. Google's transition article says Settings → Skills, while its skills help page says Customize → Skills. Use whichever your account shows.
Click Create manually.
Copy the Gem's name, description and instructions into the skill. Google says the name is reformatted automatically.
Click Create.

If the Gem had no knowledge files, you're done.

Step 3: Add the files (only if the Gem had them)

On the Skills page, hover over the new skill and choose Download from its actions menu. You get a .zip file containing a SKILL.md file.
Unzip it and move SKILL.md into the folder with your Gem's files.
Back on the Skills page, choose Replace skill for the same skill.
Upload the folder. Google notes that the folder name must match the skill name.

Google says uploading files to create skills currently works only in the Gemini web app and the Gemini app on Mac.

Make the converted skill work like a skill

Copying a Gem's instructions across gets you a working skill, but a Gem and a skill are triggered differently. You opened a Gem deliberately. Gemini can use a skill automatically when a request matches it, and you can also call one in a chat by typing / (Google says this will become @) and its name.

That makes the skill's name and description more important than they were for your Gem. Google's guidance on writing skills says:

Name: start with a verb and avoid vague words like "helper." Google's example is plan-meal-from-recipe instead of recipe-data.
Description: write it in the third person and include "Use when…" with specific situations. Google gives a 1,024-character limit.
Instructions: keep them short, "cheat sheets, not manuals." Add a "common mistakes" section, and say what Gemini should do when information is missing instead of guessing.

Example: a Gem for newsletter editing, rewritten as a skill

Before (a typical Gem description):

Newsletter helper. Helps me with my newsletter.

After:

---
name: edit-newsletter-drafts
description: Edits weekly newsletter drafts for clarity, length and a friendly tone, and suggests three subject lines. Use when reviewing a newsletter draft or preparing a newsletter to send.
---

# Edit newsletter drafts

## Steps
1. Read the whole draft. Summarize its main point in one sentence.
2. Cut repetition and trim the draft to about 400 words unless told otherwise.
3. Keep the writer's voice: friendly, plain English, short paragraphs.
4. Suggest three subject lines under 50 characters.

## Output
- Edited draft
- Three subject lines
- A short list of changes you made

## Common mistakes to avoid
- Adding facts, links or offers that aren't in the draft
- Changing names, dates or prices

If the draft has no clear main point, ask what it should be instead of guessing.

The instructions are only an illustration; use your own Gem's content. The pattern to copy: a verb-first name, a description that says what and when, short steps, an output format and a mistakes list.

Managing your skills after the move

Only active skills are used automatically. Turn a skill off or on from the Skills page. Google says you can create as many skills as you like, but only 100 can be active at a time.
Updating files means re-uploading the whole skill with its files.
Deleting a skill can't be undone.
Requirements: Google's skills help page says you must be 18 or over, signed in, with Keep Activity on. Skills work on the Gemini web app, mobile app and Mac app, and don't require a Google AI subscription. Google's admin page says skills in the Gemini app are for "users of all ages," and its transition article says "over 18," so the age rule may still be settling.

For work and school accounts

Gems keep working into 2027 (March 1 for business, June 1 for education, both "no sooner than"). But Google recommends that admins tell users the dates and rebuild critical Gems early.
Workspace Studio: replace "Ask a Gem" steps before the cut-off. Google points flow owners to its Workspace Studio transition guide.
Skills inside Workspace apps are delayed until further notice (Workspace Updates, October 13, 2026). Plan around the Gemini app for now.
Education: for Classroom and Gemini LTI, Google recommends moving to Gemini Notebook, with Guided Learning "coming soon to Classroom."

Common mistakes

Assuming November 17 is the personal-account deadline. Google's consumer page says only "November 2026."
Not backing up your Gem's instructions. Copy them into a document now, even if you plan to wait.
Forgetting that migrated skills arrive switched off. You'll need to review and activate each one.
Moving a Gem that depends on Canvas or Deep Research and expecting the same behavior. Those tools don't work with skills yet.
Keeping a vague Gem-style description. Skills are chosen by their description, so rewrite it with "Use when…".
Uploading Word or Excel knowledge files. Gemini's skills page lists binary formats like .docx and .xlsx as unsupported. Text files, PDFs and images are accepted, so saving a Word file as a PDF or plain text first is the simple fix (our suggestion, not a Google instruction).

FAQ

Will I lose my Gems?
Google says it will automatically recreate them as skills when Gems are removed. They'll arrive as inactive drafts you need to review.

Do I need a paid plan for skills?
No. Google's help page says skills are available without a Google AI subscription.

Can I use the converted skill outside Gemini?
Google says skills use the open SKILL.md format, "without platform lock-in." Other apps have their own upload rules. The article "How to Create a Claude Skill You Can Reuse in ChatGPT and Gemini" covers them.

What if I don't see Skills yet?
The Gemini app rollout runs until mid-November 2026, according to Google. Check again later, and make sure you meet the requirements above.

Wrapping up

The safest plan is simple. Back up every Gem's instructions now, move the few you depend on, and rewrite their descriptions so Gemini knows when to use them. Then check Google's pages again in November for the exact dates and migration details.

Sources

All checked on October 19, 2026.

Gemini Help — About the transition from Gems to skills
Google Workspace Admin Help — About the transition from Gems to skills (its Workspace skills rollout dates are older than the Workspace Updates post below)
Google Workspace Updates (2026-10-13)
Gemini Help — Create & manage skills
Gemini Help — Write effective skills

n8n AI Agent Tutorial (2026): The New Agents Feature vs the AI Agent Node, on Free Self-Hosted n8n

AI Sensei LAB — Mon, 19 Oct 2026 22:32:47 +0000

This n8n AI agent tutorial builds the same small chat agent two ways on free, self-hosted n8n: with the AI Agent workflow node, and with the newer Agents feature (in Preview). You'll learn what each one needs, how to run both with a free local model, and what went wrong in a real test.

Disclosure: this article was drafted and edited with AI tools (#abotwrotethis). Everything under "What happened" was run on October 20, 2026, on n8n 2.43.8 (Community edition) with a local model. The setup was driven through n8n's REST API, not by clicking in the editor, so editor button and menu names in this article come from n8n's docs and weren't checked on screen. No paid model or API key was used.

n8n now has two ways to build an AI agent. Most tutorials show the AI Agent node inside a workflow. Newer versions also include Agents, which you build in an Agent Builder instead of on the workflow canvas. Both ran on the free Community edition in this test. They're designed for different jobs.

The two approaches, in n8n's words

The AI Agent node is a workflow node. n8n's docs say: "Connect a chat model and one or more tools, and the agent decides which tools to call to complete a task." It also says: "You must connect at least one tool sub-node to an AI Agent node." The older v1 of the node, which had an agent-type setting, "will be removed from n8n 3.0", so update old workflows to the current version.

Agents are separate from workflows. n8n's docs call an agent "an autonomous assistant you build in n8n" with a model, instructions, and capabilities like tools, skills and a knowledge base, and say to use an agent "when work is too open-ended for a fixed workflow". Key points from the "Build and manage agents" page:

Self-hosted availability: "All plans from n8n 2.32.3".
"Agents are in Preview. They can make mistakes, and their behavior may change while the feature is in development."
"Agents are on by default on all plans". An owner or admin can switch them off in Settings > Agents, and that setting "doesn't affect the AI Agent workflow node."
"Queue mode isn't supported for agents yet". Run agents in regular mode.
"One turn with an agent counts as one execution."

	AI Agent node	Agents (Preview)
Where you build it	Workflow canvas	Agent Builder
Model	A chat model sub-node	Provider + model chosen in the agent
Tools	Tool sub-nodes (at least one required)	Built-in integrations, workflows, custom tools, MCP servers
Memory	A memory sub-node (for example Simple Memory)	Session memory on by default; episodic memory needs an OpenAI credential
Knowledge base	Build it yourself in the workflow	Knowledge tab; on self-hosted it needs a Daytona sandbox (Preview)
Reach it from	Whatever triggers the workflow	Chat panel, Slack, Telegram, Linear, schedules
Status	No Preview label in its docs	Preview

Use the node when the AI step sits inside a fixed process. Try an Agent when people need to chat with an assistant that picks its own tools.

Free setup: what was run

n8n's "Compare editions" page says the Community edition "is what n8n runs without a license key" and includes "almost the complete feature set". It lacks things like projects, sharing, SSO, environments and Git version control.

The test machine had no Docker, so n8n was installed from npm. The npm package for n8n 2.43.8 declares "node": ">=24.0.0", so Node.js 24 was needed (the test machine's Node 20 didn't meet it):

mkdir n8n-test && cd n8n-test
npm init -y
npm install n8n@2.43.8
npx n8n start

The startup log ended with Version: 2.43.8 and Editor is now accessible via: http://localhost:5678. It also printed: "Running n8n outside a container is deprecated. Future versions will require running n8n via the official Docker image." If you have Docker, use n8n's official image instead.

After creating the owner account, the instance's settings API reported plan name "Community", and the Agents settings endpoint returned enabled: true. No registration or license key was needed for Agents.

A free model. Both builds used a local model through Ollama: Qwen2.5-1.5B-Instruct, a small model that runs on a CPU. That keeps the test free, but a 1.5B model is weak, and you'll see that below. Larger local models or a free API tier may do much better; neither was tested here.

Build 1: AI Agent node + Chat Trigger + memory + one tool

The workflow has five nodes:

Chat Trigger ("When chat message received"), set to public so it can be called over HTTP.
AI Agent (version 3.1 in this install), with a system message: "You are a helpful assistant. For any arithmetic, always use the calculator tool and report its result."
Ollama Chat Model sub-node, using an Ollama credential with base URL http://127.0.0.1:11434.
Simple Memory sub-node, default settings.
Calculator tool sub-node: a read-only tool, which makes it safe for a first test.

Here's the workflow JSON used in the test, with the credential reference removed. It was created through the REST API; after importing it, select your own Ollama credential on the model node.

{
  "name": "Build 1 - AI Agent node (local Ollama)",
  "nodes": [
    {
      "name": "When chat message received",
      "type": "@n8n/n8n-nodes-langchain.chatTrigger",
      "typeVersion": 1.4,
      "position": [
        0,
        0
      ],
      "parameters": {
        "public": true,
        "options": {}
      }
    },
    {
      "name": "AI Agent",
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 3.1,
      "position": [
        300,
        0
      ],
      "parameters": {
        "options": {
          "systemMessage": "You are a helpful assistant. For any arithmetic, always use the calculator tool and report its result."
        }
      }
    },
    {
      "name": "Ollama Chat Model",
      "type": "@n8n/n8n-nodes-langchain.lmChatOllama",
      "typeVersion": 1,
      "position": [
        200,
        250
      ],
      "parameters": {
        "model": "qwen2.5-1.5b-local",
        "options": {}
      }
    },
    {
      "name": "Simple Memory",
      "type": "@n8n/n8n-nodes-langchain.memoryBufferWindow",
      "typeVersion": 1.3,
      "position": [
        350,
        250
      ],
      "parameters": {}
    },
    {
      "name": "Calculator",
      "type": "@n8n/n8n-nodes-langchain.toolCalculator",
      "typeVersion": 1,
      "position": [
        500,
        250
      ],
      "parameters": {}
    }
  ],
  "connections": {
    "When chat message received": {
      "main": [
        [
          {
            "node": "AI Agent",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Ollama Chat Model": {
      "ai_languageModel": [
        [
          {
            "node": "AI Agent",
            "type": "ai_languageModel",
            "index": 0
          }
        ]
      ]
    },
    "Simple Memory": {
      "ai_memory": [
        [
          {
            "node": "AI Agent",
            "type": "ai_memory",
            "index": 0
          }
        ]
      ]
    },
    "Calculator": {
      "ai_tool": [
        [
          {
            "node": "AI Agent",
            "type": "ai_tool",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  }
}

What happened

After publishing the workflow, two messages went to the chat endpoint in the same session:

> What is 1234 * 56? Use the calculator.
{"output":"The result of 1234 * 56 is 69,104."}

> Now divide that result by 8.
{"output":"The result of 69,104 / 8 is 8,638."}

Both answers are correct. The execution data for the second run shows the Calculator received 69104 / 8, so the agent used the tool, and Simple Memory carried "that result" over from the first message. Each reply took about 2 to 3 seconds on CPU.

Build 2: the same assistant as an Agent

n8n's docs describe the Agent Builder flow in the editor: select your project from the left menu, go to the Agents tab, select Create Agent, name the agent, pick a provider and model in the Model field, write Instructions, and add tools or skills. Selecting Preview in the header tests the draft "without publishing". This test made the same steps through the REST API, so these labels weren't seen on screen.

Through the API, the agent was created in the owner's personal project (the Community edition doesn't include the Projects feature, per "Compare editions"). Before any setup, n8n's validation listed three missing items: instructions, model, and credential.

The model problem

The Agents model catalog that the API returned on this instance had 16 provider IDs: openai, anthropic, google, azure-openai, aws-bedrock, xai, groq, openrouter, deepseek, cohere, mistral, vercel, nvidia, moonshotai, alibaba and minimax. Ollama wasn't one of them, although the AI Agent node has an Ollama Chat Model sub-node.

Undocumented workaround (tested once, may break). Ollama's docs say it "supports a subset of the OpenAI API", served at http://localhost:11434/v1/, and that the client "requires an API key value, but Ollama ignores it". So the test used n8n's OpenAI credential type with:

API key: ollama (any value)
Base URL: http://127.0.0.1:11434/v1
Model: qwen2.5-1.5b-local under the OpenAI provider

With that, validation returned valid and the Preview chat below got replies. This isn't described in the n8n docs that were checked, and it was tested only on n8n 2.43.8 with Ollama 0.40.6, for plain chat with no tools. Tool calls through this route weren't tested. Treat it as an experiment, not a supported setup: an n8n update could break it. If you need a supported setup, pick one of the listed providers.

What happened

Instructions: "You are a helpful assistant. Answer in one or two short sentences." No tools. Three messages in one Preview session:

> In one sentence, what is n8n?
N8n is an open-source automation platform designed for building and managing workflows.

> What is 1234 * 56?
1234 * 56 equals 70,064.

> What did I ask you first in this chat?
You didn't ask anything initially. This is a conversation with a helpful assistant. ...

Those are real replies from the small local model, and they show two problems:

Arithmetic without a tool is wrong. The correct answer is 69,104, which Build 1 got through the Calculator. Give an agent a tool for anything that has to be exact.
The recall question failed. All three turns ran in the same Preview session. n8n's execution records show about the same prompt size on every turn (3,460, 3,462 and 3,460 prompt tokens), which suggests the earlier turns weren't sent to the model on the third turn. Whether that comes from the workaround above, the Preview chat, or something else couldn't be determined in this test. The docs say session memory "is on by default and needs no setup", so try it with a listed provider before drawing conclusions.

The first answer is the model's own wording. n8n's LICENSE.md in the 2.43.8 package says most of its code is under n8n's "Sustainable Use License", so don't take "open-source" from a small model as a licensing statement.

Human approval for tools that change data

Both builds above only read data. Once a tool can send, delete or update something, add a human check. For Agents, n8n's docs say: "For sensitive tools, you can require approval before the agent runs them", and in the chat you then select Approve or Reject. This wasn't tested here, because no write tool was connected.

Limits and caveats

Preview means change. Agents' behavior "may change while the feature is in development". Date your notes and recheck after upgrades.
Queue mode: not supported for agents yet, per the docs.
Knowledge base on self-hosted needs a Daytona sandbox and is itself in Preview. Not tested.
Episodic memory (recall across sessions) needs an OpenAI credential. Not tested.
Channels (Slack, Telegram, Linear) need a public WEBHOOK_URL on self-hosted. Not tested.
Not tested at all: attaching a tool or skill to the Agent, publishing the Agent, the n8n Assistant, Docker, and any cloud model.

Which one should you start with?

If you're new, start with Build 1. It isn't in Preview, it has a built-in Ollama Chat Model sub-node, and you can see every step in the execution log. Move to Agents when you want an assistant people can chat with directly, and when you're comfortable with a feature that's still in Preview.

Sources (checked October 20, 2026): n8n Docs "Build and manage agents" (https://docs.n8n.io/build/build-and-manage-agents), "AI Agent" node (https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent), "Compare editions" (https://docs.n8n.io/deploy/host-n8n/community-edition-features); Ollama Docs "OpenAI compatibility" (https://docs.ollama.com/api/openai-compatibility).

How to Translate SRT Subtitles with ChatGPT (Japanese to English) Without Breaking the Timing + a Free Python Checker

AI Sensei LAB — Mon, 19 Oct 2026 22:31:14 +0000

If you translate SRT subtitles with ChatGPT by pasting the whole file, cue numbers and timecodes can drift. This guide shows how to keep the structure locked, translate Japanese to English with any chatbot, and check the result with a free Python script that tests line length, reading speed, duration and gaps against Netflix's public timed text guidelines.

Disclosure: this article was drafted and edited with AI tools (#abotwrotethis). The Python script was run on Python 3.13.5 on October 20, 2026, and the checker output below is real. The English sample translation was written for this article by the AI tool that drafted it. The prompt in this article was not run in ChatGPT, Claude or Gemini, so no chatbot output is shown.

Pasting an SRT file into a chatbot and asking for English usually works for a few lines. On longer files, things break: two cues get merged, a cue number disappears, or a timecode comes back slightly different. Japanese adds its own problem. A sentence often runs across two or three cues, with the verb at the very end, so translating cue by cue gives you English that reads backwards.

The fix is to never let the model touch the parts it shouldn't change.

What must never change in an SRT

An SRT cue has three parts: an index, a timing line, and one or more lines of text, followed by a blank line.

4
00:00:10,000 --> 00:00:12,400
駅前の新しいカフェ、

SRT is a simple plain-text format, so treat this structure as the contract. When you translate:

the number of cues must stay the same,
every index must stay the same,
every timing line must stay byte-for-byte the same,
only the text changes.

If a line is too long to read in time, shorten the English. Don't retime the cue during translation. Retiming is a separate job with its own rules.

Why Japanese to English is harder

Take cues 4–6 from the sample used below:

駅前の新しいカフェ、                  (the new café by the station,)
昨日オープンしたって聞いたんだけど      (I heard it opened yesterday, but)
行ってみない?                          (want to go?)

Translated one cue at a time, cue 4 becomes "The new café in front of the station," with nothing to attach to. The English needs to know what comes next. The model needs the neighboring cues as context, while you still get back exactly one translation per cue.

Japanese also drops subjects ("すぐ追いつくから!" has no "I") and puts tone in sentence endings ("なんとかなるでしょ"). Both need context, not a dictionary.

Step 1: lock the structure (SRT to JSON)

The script below turns the SRT into a JSON list of id + text, plus the previous and next cue as read-only context. Timecodes stay in the original file and never go to the model.

python3 srtcheck.py to-json sample_ja.srt > cues.json

Real output for cue 4:

{
  "id": "4",
  "text": "駅前の新しいカフェ、",
  "prev": "……まあ、いっか。なんとかなるでしょ。",
  "next": "昨日オープンしたって聞いたんだけど"
}

Step 2: the prompt

Paste this into ChatGPT, Claude or Gemini, followed by the contents of cues.json. It's a template: it wasn't run in any chatbot for this article, so check the first reply with the script before you trust it. For long files, send 30 to 50 cues per message so the reply doesn't get cut off. Keep the batches in order.

You are translating Japanese subtitles into natural U.S. English.

Input: a JSON array. Each item has "id", "text" (translate this),
and "prev"/"next" (neighboring cues, for context only - do not translate them).

Rules:
1. Return a JSON array with exactly one item per input item, same order,
   each item {"id": <same id>, "text": <English>}. Nothing else.
2. Never merge, split, add or drop items. Never change an id.
3. When a Japanese sentence runs across several cues, translate the whole
   sentence, then divide the English across those same cues in a natural
   reading order. Each cue must still make sense where it breaks.
4. Keep each cue short: at most 2 lines, at most 42 characters per line.
   Use "\n" for a line break. Prefer shorter wording to long, literal wording.
5. Keep the speaker's tone (casual stays casual). Add a subject only when
   English needs one.
6. Use the single ellipsis character (…) instead of three dots,
   and no em or en dashes.
7. If something cannot be translated with confidence (a name, a pun),
   keep your best version and add "[CHECK]" at the end of that text.

Rules 4 and 6 come from Netflix's English (USA) Timed Text Style Guide, which sets 42 characters per line and a maximum of two lines, says en and em dashes are not permitted, and asks for the single ellipsis character instead of three dots. You can remove them if your platform uses different rules.

Step 3: rebuild the SRT

Save the model's reply as translated_en.json. The script takes the timing lines from the original file and only the text from the JSON, so the model can't change a timecode even if it tries. If an ID is missing, it stops with an error.

This is the translation used for the test. It was written for this article by the AI tool that drafted it, not generated with the prompt above:

[
  {"id": "1", "text": "Wait, it's already this late?"},
  {"id": "2", "text": "Sorry, go on ahead.\nI'll catch up!"},
  {"id": "3", "text": "Oh well. It'll work out."},
  {"id": "4", "text": "That new café by the station"},
  {"id": "5", "text": "opened yesterday, I heard."},
  {"id": "6", "text": "Want to check it out?"},
  {"id": "7", "text": "Yeah!"}
]

python3 srtcheck.py from-json sample_ja.srt translated_en.json > sample_en.srt

Step 4: run the checker

python3 srtcheck.py check sample_ja.srt sample_en.srt

The checker compares the two files and tests each English cue against these limits:

Check	Limit	Source
Cue count, indexes, timing lines	identical to source	(structure)
Characters per line	42	Netflix English (USA) guide
Lines per cue	2	Netflix English (USA) guide
Reading speed	up to 20 characters per second (adult programs)	Netflix English (USA) guide
Maximum duration	7 seconds	Netflix General Requirements
Minimum duration	5/6 of a second (20 frames at 24 fps)	Netflix General Requirements
Gap between cues	at least 2 frames; in 24 fps content, gaps of 3 to 11 frames must be closed to 2	Netflix Subtitle Timing Guidelines
Punctuation	no double spaces, no en/em dashes, ellipsis character	Netflix English (USA) guide

Reading speed here is counted as all characters including spaces, excluding line breaks, divided by the cue's duration. Netflix's page gives the limit but not the counting method, so treat this as an estimate.

Frame-based checks assume 24 fps unless you pass --fps (for example --fps 25). Two Netflix pages word the minimum duration differently: General Requirements says "5/6 (five-sixths) of a second per subtitle event (e.g. 20 frames for 24fps)", while the Subtitle Timing Guidelines say "20 frames (or 4/5 sec)". At 24 fps, 20 frames is 5/6 of a second (0.833 s), not 4/5 (0.8 s). The script uses 5/6 of a second, the stricter value. The 3-to-11-frame gap rule is written for 24 fps content, so the script only applies it with --fps 24.

Real output for the translation above:

WARN    cue 1->2: gap 4.8 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 2->3: gap 7.2 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 4->5: gap 1.92 frames (min 2)
WARN    cue 7: duration 0.800s (min 5/6 s = 0.833s, 20 frames at 24 fps)

7 cues checked: 0 error(s), 4 warning(s)

No errors: the cue count, indexes and timing lines all match, and every line fits. The four warnings are about the source timing, not the translation. The sample was timed by hand for this article. Gaps of 4.8 and 7.2 frames, an 80 ms gap (1.92 frames), and a 0.8-second cue would all need a timing pass under Netflix's rules. (The 0.8-second cue is exactly the case where the two Netflix pages disagree: it meets "4/5 sec" but not "5/6 of a second".) The checker flags them, so you know they were there before the translation.

Real output for a naive version, translated line by line and pasted back by hand:

ERROR   cue count changed: source 7, target 6
ERROR   cue 6: timecode changed (00:00:15,084 --> 00:00:17,500 -> 00:00:15,084 --> 00:00:19,000)
ERROR   cue 2: line has 73 chars (max 42): "I'm sorry, please go ahead first and I will catch up with you right away!"
ERROR   cue 3: line has 45 chars (max 42): "...Well, it's fine. It will work out somehow."
WARN    cue 1->2: gap 4.8 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 2: reading speed 28.1 CPS (max 20) - shorten the text, don't retime
WARN    cue 2->3: gap 7.2 frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)
WARN    cue 3: three dots; use the single ellipsis character
WARN    cue 4->5: gap 1.92 frames (min 2)

6 cues checked: 4 error(s), 5 warning(s)

These are the kinds of mistakes this article is about: cues 6 and 7 were merged into one (and its end time stretched), a literal line ran to 73 characters at 28.1 characters per second, and three dots were used where Netflix asks for the ellipsis character.

The exit code is 1 when there are errors and 0 when there are only warnings, so you can use it in a script or a CI job.

Fixing what the checker flags

Line too long / reading speed too high: shorten the English. "Sorry, go on ahead. I'll catch up!" says what "I'm sorry, please go ahead first and I will catch up with you right away!" says, in less than half the characters. You can also ask the model to shorten only the flagged IDs.
Cue count or timecode changed: don't fix it by hand. Rebuild from the JSON with from-json, which always uses the source timing.
Gaps and durations: these are timing issues in the source. Fix them in your subtitle editor as a separate timing pass, following Netflix's Subtitle Timing Guidelines.

What still needs a person who reads Japanese

The checker can tell you a line fits. It can't tell you it's right. Have someone who reads Japanese check:

names and how they're romanized,
jokes, puns and wordplay,
politeness levels (keigo) and how formal the English should sound,
anything you marked [CHECK].

The full script

Standard library only. Save it as srtcheck.py.

#!/usr/bin/env python3
"""srtcheck.py - round-trip an SRT through JSON and check a translated SRT.

  python3 srtcheck.py to-json  source.srt  > cues.json
  python3 srtcheck.py from-json source.srt translated.json > target.srt
  python3 srtcheck.py check    source.srt  target.srt [--fps 24]

Standard library only. Limits come from Netflix's public Timed Text Style Guide
pages (English (USA), General Requirements, Subtitle Timing Guidelines).
--fps sets the frame rate used for frame-based checks (default 24).
"""
import json, re, sys

MAX_CHARS_PER_LINE = 42   # English (USA) guide, II.3
MAX_LINES = 2             # English (USA) guide, II.13
MAX_CPS = 20.0            # English (USA) guide, II.17 (adult programs)
MAX_DURATION = 7.0        # General Requirements, 1. Duration
MIN_DURATION = 5 / 6      # General Requirements, 1. Duration: 5/6 s (20 frames at 24 fps)
MIN_GAP_FRAMES = 2        # Timing Guidelines, 5: minimum 2 frames between subtitles

TC = re.compile(r"(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})")

def parse(path):
    text = open(path, encoding="utf-8-sig").read().replace("\r\n", "\n")
    cues = []
    for block in re.split(r"\n\s*\n", text.strip()):
        lines = block.split("\n")
        if len(lines) < 2 or not TC.search(lines[1]):
            raise SystemExit(f"Cannot parse block:\n{block}")
        m = TC.search(lines[1]).groups()
        t = [int(x) for x in m]
        start = t[0]*3600 + t[1]*60 + t[2] + t[3]/1000
        end = t[4]*3600 + t[5]*60 + t[6] + t[7]/1000
        cues.append({"id": lines[0].strip(), "timing": lines[1].strip(),
                     "start": start, "end": end, "lines": lines[2:]})
    return cues

def to_json(src):
    cues = parse(src)
    out = []
    for i, c in enumerate(cues):
        out.append({"id": c["id"], "text": "\n".join(c["lines"]),
                    "prev": "\n".join(cues[i-1]["lines"]) if i else "",
                    "next": "\n".join(cues[i+1]["lines"]) if i + 1 < len(cues) else ""})
    print(json.dumps(out, ensure_ascii=False, indent=2))

def from_json(src, translated):
    cues = parse(src)
    tr = {str(x["id"]): x["text"] for x in json.load(open(translated, encoding="utf-8"))}
    missing = [c["id"] for c in cues if c["id"] not in tr]
    if missing:
        raise SystemExit(f"Translated JSON is missing ids: {', '.join(missing)}")
    blocks = [f'{c["id"]}\n{c["timing"]}\n{tr[c["id"]].strip()}' for c in cues]
    print("\n\n".join(blocks) + "\n")

def check(src, tgt, fps=24.0):
    a, b = parse(src), parse(tgt)
    errors, warnings = [], []
    if len(a) != len(b):
        errors.append(f"cue count changed: source {len(a)}, target {len(b)}")
    for x, y in zip(a, b):
        if x["id"] != y["id"]:
            errors.append(f"cue {x['id']}: index changed to {y['id']}")
        if x["timing"] != y["timing"]:
            errors.append(f"cue {x['id']}: timecode changed ({x['timing']} -> {y['timing']})")
    for i, c in enumerate(b):
        cid, dur = c["id"], c["end"] - c["start"]
        text = [l.strip() for l in c["lines"] if l.strip()]
        chars = sum(len(l) for l in text)          # characters incl. spaces, excl. line breaks
        if not text:
            errors.append(f"cue {cid}: empty text")
        if len(text) > MAX_LINES:
            errors.append(f"cue {cid}: {len(text)} lines (max {MAX_LINES})")
        for l in text:
            if len(l) > MAX_CHARS_PER_LINE:
                errors.append(f"cue {cid}: line has {len(l)} chars (max {MAX_CHARS_PER_LINE}): {l!r}")
        if dur > 0 and chars / dur > MAX_CPS:
            warnings.append(f"cue {cid}: reading speed {chars/dur:.1f} CPS (max {MAX_CPS:g}) - shorten the text, don't retime")
        if dur > MAX_DURATION:
            warnings.append(f"cue {cid}: duration {dur:.2f}s (max {MAX_DURATION:g}s)")
        if dur < MIN_DURATION - 1e-6:
            warnings.append(f"cue {cid}: duration {dur:.3f}s (min 5/6 s = {MIN_DURATION:.3f}s, {MIN_DURATION*fps:g} frames at {fps:g} fps)")
        for l in text:
            if "  " in l: warnings.append(f"cue {cid}: double space")
            if "\u2013" in l or "\u2014" in l: warnings.append(f"cue {cid}: en/em dash (not permitted)")
            if "..." in l: warnings.append(f"cue {cid}: three dots; use the single ellipsis character")
        if i + 1 < len(b):
            gap_frames = round((b[i+1]["start"] - c["end"]) * fps, 2)
            if gap_frames < MIN_GAP_FRAMES:
                warnings.append(f"cue {cid}->{b[i+1]['id']}: gap {gap_frames:g} frames (min {MIN_GAP_FRAMES})")
            elif fps == 24 and 3 <= gap_frames <= 11:
                warnings.append(f"cue {cid}->{b[i+1]['id']}: gap {gap_frames:g} frames (24 fps rule: gaps of 3-11 frames must be closed to 2; source timing, fix in a timing pass)")
    for e in errors: print("ERROR  ", e)
    for w in warnings: print("WARN   ", w)
    print(f"\n{len(b)} cues checked: {len(errors)} error(s), {len(warnings)} warning(s)")
    return 1 if errors else 0

if __name__ == "__main__":
    args = sys.argv[1:]
    fps = 24.0
    if "--fps" in args:
        k = args.index("--fps"); fps = float(args[k+1]); del args[k:k+2]
    if len(args) == 2 and args[0] == "to-json": to_json(args[1])
    elif len(args) == 3 and args[0] == "from-json": from_json(args[1], args[2])
    elif len(args) == 3 and args[0] == "check": sys.exit(check(args[1], args[2], fps))
    else: print(__doc__); sys.exit(2)

The sample files

sample_ja.srt (cues 1 to 3 are a short team-written test text, cues 4 to 7 were written for this article):

1
00:00:01,000 --> 00:00:03,200
えっ、もうこんな時間?

2
00:00:03,400 --> 00:00:06,000
ごめん、先に行ってて。すぐ追いつくから!

3
00:00:06,300 --> 00:00:09,000
……まあ、いっか。なんとかなるでしょ。

4
00:00:10,000 --> 00:00:12,400
駅前の新しいカフェ、

5
00:00:12,480 --> 00:00:15,000
昨日オープンしたって聞いたんだけど

6
00:00:15,084 --> 00:00:17,500
行ってみない?

7
00:00:18,200 --> 00:00:19,000
うん!

naive_en.srt, used for the failing run:

1
00:00:01,000 --> 00:00:03,200
Eh, is it already this time?

2
00:00:03,400 --> 00:00:06,000
I'm sorry, please go ahead first and I will catch up with you right away!

3
00:00:06,300 --> 00:00:09,000
...Well, it's fine. It will work out somehow.

4
00:00:10,000 --> 00:00:12,400
The new café in front of the station,

5
00:00:12,480 --> 00:00:15,000
I heard it opened yesterday, but

6
00:00:15,084 --> 00:00:19,000
won't you go? Yes!

Sources (checked October 20, 2026; Netflix pages re-opened by the editor): Netflix Partner Help Center, "English (USA) Timed Text Style Guide" (https://partnerhelp.netflixstudios.com/hc/en-us/articles/217350977-English-USA-Timed-Text-Style-Guide), "Timed Text Style Guide: General Requirements" (https://partnerhelp.netflixstudios.com/hc/en-us/articles/215758617-Timed-Text-Style-Guide-General-Requirements), and "Timed Text Style Guide: Subtitle Timing Guidelines" (https://partnerhelp.netflixstudios.com/hc/en-us/articles/360051554394-Timed-Text-Style-Guide-Subtitle-Timing-Guidelines).

How to Create a Claude Skill You Can Reuse in ChatGPT and Gemini

AI Sensei LAB — Mon, 19 Oct 2026 09:46:35 +0000

One SKILL.md file, three apps: a portable template, the upload steps for each, and the limits that differ between them.

Disclosure: this article was drafted and edited with AI tools.

If you keep pasting the same long prompt into a chat window, a skill is the fix that Claude, ChatGPT and Gemini now all offer. All three build on the same open format: a folder with a file called SKILL.md inside it. In principle, that means you write the file once and upload it to each app.

In practice, each app has its own upload screen, plan rules and limits. This guide walks through building one skill that stays inside the strictest rules of all three, then shows where to upload it in each app.

How this guide was made: every step and limit below comes from the official Anthropic, OpenAI and Google documentation, checked on October 19, 2026. The steps have not been tried hands-on in the three apps. These features are changing quickly, so check the linked pages before you rely on a detail, and expect the screens to look slightly different.

What a skill is (and when you don't need one)

A skill is a saved set of instructions, plus optional files, that the AI loads only when your request matches it. All three vendors describe the same pattern. The app reads each skill's short name and description first. It opens the full instructions only when it decides the skill is relevant, and opens any extra files only when a step calls for them.

That's why skills suit repeated tasks you want done the same way every time: a report format, a review checklist, a multi-step routine.

You probably don't need a skill when:

It's a one-off task. Just describe it in the chat.
The instruction applies to every conversation. Claude's docs point you to your personal preferences or project instructions for that, because a skill only loads when a task matches.
The task keeps changing. Google's guidance says to skip skills when the steps change too often to keep up to date.
The app already does it well without help. Google lists this as a reason to skip one too.

The anatomy of a SKILL.md file

A skill is a folder. The only required file is SKILL.md:

extract-action-items/
└── SKILL.md

Optional folders such as references/, assets/ and scripts/ can sit next to it. For a skill you want to carry between apps, start without them (more on why below).

SKILL.md has two parts:

Frontmatter: a short block between two --- lines with two required fields, name and description.
Body: plain Markdown instructions the AI follows once the skill loads.

---
name: your-skill-name
description: What the skill does. Use when [the situations it's for].
---

# Instructions go here

Portable rules: write to the strictest limit

The three apps don't publish identical rules, so the safe approach is to satisfy all of them at once.

The name field

Use only lowercase letters, numbers and hyphens, up to 64 characters. The open Agent Skills specification and Claude's docs both require this, and Gemini's help page requires lowercase words separated by hyphens. The specification also says the name can't start or end with a hyphen or contain two hyphens in a row.
Make the folder name exactly match name. Claude's docs and the specification both require it.
Don't put "claude" or "anthropic" in the name. Claude's developer docs list these as reserved words.
Start with a verb. Google suggests action names like plan-meal-from-recipe rather than recipe-data.

The description field

Say what the skill does, then when to use it. Every vendor stresses this, because the description is what the app reads to decide whether to load the skill.
Write it in the third person ("Turns…", not "I can help you…"). Both Claude's best-practices guide and Google's help page say so.
Keep it under 200 characters. The open specification, Claude's developer docs and Gemini's help page all give a 1,024-character limit. One Claude Help Center article still says 200, next to other details that look older than the current specification. Staying under 200 is safe in every case.
Put the main use case and trigger words first. OpenAI's skills guide says Codex shortens descriptions when many skills are installed, and advises front-loading trigger words so a shortened description still matches.

The body

Keep it short and focused on one job. Claude's docs suggest under 500 lines, and Google calls skills "cheat sheets, not manuals."
Prefer plain instructions over scripts. Gemini doesn't support scripts that need the internet, and it accepts only plain-text files plus PDFs and images (no .docx or .xlsx). Claude's API runs skills with no network access, and ChatGPT scans uploaded skills before they become available. An instructions-only skill avoids all of these differences.

Build the example skill step by step

The example turns pasted meeting notes into a list of action items, each with an owner and a due date when the notes give one, plus any open questions. It's a good first skill: it's a job you repeat after every meeting, it benefits from a fixed sequence of steps, and it needs nothing but instructions.

Step 1: Write the task in one sentence

Claude's docs suggest starting with a single sentence describing the task and what a good result looks like. That sentence becomes your description:

Turns pasted meeting notes into a list of action items with owners, due dates if stated, and open questions. Use when processing notes from a meeting, call, or standup.

That's 168 characters: third person, what first, then "Use when…".

Step 2: List inputs, steps and output

OpenAI's guide suggests a skill should state the job, the required inputs, numbered steps, the output format and final checks. Google adds two habits worth copying: a "common mistakes" section, and telling the AI what to do when information is missing instead of guessing.

Step 3: Create the folder and file

Make a folder named extract-action-items. Inside it, create a plain-text file named SKILL.md, using a plain text editor rather than a word processor. Paste in the template below.

The complete SKILL.md (copy and adapt)

---
name: extract-action-items
description: Turns pasted meeting notes into a list of action items with owners, due dates if stated, and open questions. Use when processing notes from a meeting, call, or standup.
---

# Extract action items from meeting notes

## Inputs
- The meeting notes, pasted as text (required)
- The meeting date, if the notes don't include it

If no notes are provided, ask for them. Do not guess what was discussed.

## Workflow
Copy this checklist and work through it in order:
- [ ] 1. Read the notes
- [ ] 2. Pull out the action items
- [ ] 3. Collect open questions
- [ ] 4. Check the list against the notes

### 1. Read the notes (do not list anything yet)
Note briefly:
- What the meeting was about, in one sentence
- The people named in the notes
- Any decisions that were made

### 2. Pull out the action items
For each task someone agreed to do, or was asked to do:
- Write the task as a short phrase that starts with a verb.
- Owner: the person named for it. If nobody is named, write "Unassigned".
- Due date: only if the notes state one, in the notes' own wording. Otherwise write "Not stated".
- Do not invent tasks, owners, or dates that are not in the notes.

### 3. Collect open questions
List questions that were raised but not answered, and topics still waiting for a decision.
Also list any action item whose owner or meaning is unclear.

### 4. Check the list against the notes
Reread the notes from the top.
Add any task you missed, and remove any item the notes do not support.

## Output format
1. **Summary**: one sentence on what the meeting covered
2. **Action items**: a table with the columns Task, Owner, Due date
3. **Open questions**: a bulleted list. If there are none, say so.

## Common mistakes to avoid
- Turning a general discussion point into a task nobody agreed to
- Guessing the owner from whoever spoke most
- Converting a vague timeframe ("soon", "after the launch") into an exact date
- Missing tasks mentioned in passing near the end of the notes

Change the inputs, steps and mistakes to fit your own task. Keep the structure: description, inputs, a numbered checklist, an output format and a mistakes list.

Step 4: Package it

Claude expects a ZIP file, and the ZIP must contain the folder itself, not just the files inside it. On macOS or Linux, Claude's docs give this command, run from the folder that contains your skill folder:

  zip -r extract-action-items.zip extract-action-items/

If you use another tool, compress the folder rather than the file inside it.

Gemini accepts a SKILL.md file on its own, a folder, or a ZIP.
ChatGPT's help page says "Upload from your computer" but doesn't state the file type for the app.

Upload it: Claude, ChatGPT and Gemini

Claude (claude.ai and the desktop app)

Turn on code execution. Claude's help page says skills need it. On individual plans it's under Settings → Capabilities → Code execution and file creation.
Go to Customize → Skills.
Click +, then Create skill, then Upload a skill, and choose your ZIP.
Make sure the skill is toggled on.

Claude's Help Center lists skills on the Free, Pro, Max, Team and Enterprise plans. Note that one older developer page still says Pro and above, so check your own account. On Team and Enterprise, an organization owner controls whether skills and uploads are allowed.

ChatGPT

In the sidebar, select Plugins.
Open the Skills tab in the Plugin Directory.
Select Create, then Upload from your computer.
Wait for the scan. OpenAI says uploaded skills are scanned first. Most become available right away, some are marked Needs Review, and risky ones are Blocked.

Plan access is unclear right now. OpenAI's Skills help article says skills are for "eligible ChatGPT Business, Enterprise, Healthcare, and Edu users." Its pricing page, checked the same day, lists Skills on Free, Go, Plus and Pro. OpenAI's developer guide also says standalone skills are in the ChatGPT desktop app. The reliable check is whether a Skills tab appears under Plugins in your own account. Upload options may also differ by plan and by app, so don't assume a personal plan can upload on the web.

Gemini app

Go to gemini.google.com, or open the Gemini app on a Mac.
Click Customize in the sidebar (under More if you don't see it), then Skills at the top.
Click Upload, select your SKILL.md, folder or ZIP, and click Open.
Review the skill, then click Create.

Google's help page lists these requirements: you must be 18 or over, signed in, with Keep Activity on. (Google's October 13 launch post says Gemini app skills will be open to all ages, so the age rule may change.) Skills are only in the Gemini mobile app, the Mac app and the web app. A Google AI subscription isn't required. Google says skills in the Gemini app began a gradual rollout on October 13, 2026, with completion expected by mid-November. If you don't see Skills yet, your account may simply not have it.

Compatibility at a glance (from the docs, October 19, 2026)

	Claude (claude.ai)	ChatGPT	Gemini app
Where	Customize → Skills	Plugins → Skills tab	Customize → Skills
Upload format	ZIP with the skill folder at the top level	"Upload from your computer" (type not stated)	`SKILL.md`, folder, or ZIP; 100 MB total
`name`	Lowercase, numbers, hyphens; ≤64; matches folder; no "claude"/"anthropic"	Follows the open standard	Lowercase words with hyphens
`description`	1,024 (docs) vs. 200 (Help Center)	Front-load; may be shortened	1,024
Scripts / files	Allowed; needs code execution	Allowed; scanned on upload	No internet scripts; plain text, PDF and images (no .docx/.xlsx)
Call it by name	Ask explicitly ("Use my … skill")	Type `@`	Type `/` or `@`
Plans	Free, Pro, Max, Team, Enterprise (Help Center)	Conflicting (see above)	No Google AI plan needed; rolling out to mid-Nov
Updating	Re-upload the ZIP	Not covered in the help article	Re-upload the whole skill to update files

What may not carry over between apps

The file format is shared, but the apps around it aren't. Watch for these:

Extra frontmatter fields. Each vendor documents its own optional extras. Claude's Help Center mentions a dependencies field, and ChatGPT reads an optional agents/openai.yaml file. Whether the other apps ignore or reject these isn't documented, so leave them out of a portable skill.
App-specific paths. Claude's docs use a ${CLAUDE_SKILL_DIR} placeholder for script paths. Other apps don't document it.
ZIP layout. Claude requires the folder at the top of the ZIP. Gemini asks for a SKILL.md "in its main folder." If one app rejects your ZIP, try uploading the folder or the SKILL.md file directly where that's allowed.
Binary and hidden files. Gemini rejects .docx and .xlsx, and Google warns that hidden files like .DS_Store can make an upload fail.
Sharing. Each app handles sharing differently: Claude only on Team and Enterprise, ChatGPT within a workspace, and Gemini's sharing announced only for "the coming weeks."

Checklist before you upload

[ ] Folder name and name are identical, lowercase, hyphens only, ≤64 characters
[ ] name doesn't contain "claude" or "anthropic"
[ ] description says what and when, in the third person, under 200 characters
[ ] Body covers inputs, numbered steps, output format and common mistakes
[ ] The skill says what to do when information is missing
[ ] No scripts, or none that need the internet
[ ] Only plain-text files such as .md or .txt; no Office files and no hidden files like .DS_Store
[ ] No API keys, passwords or personal data anywhere in the folder
[ ] For Claude: the ZIP contains the folder, not loose files
[ ] After uploading: the skill is switched on, and you've tried a few prompts that should trigger it

Common mistakes and troubleshooting

The skill never triggers. All three vendors point to the description first. Make it more specific and include the words you'd actually type. Claude's help page also suggests checking that the skill is toggled on, and asking for it by name. In ChatGPT and Gemini, you can call it directly with @ (or / in Gemini).

The upload is rejected. Claude lists the usual causes: the ZIP is too large, the folder name doesn't match the skill name, SKILL.md is missing, or the name or description has invalid characters. For Gemini, check for binary or hidden files and the 100 MB limit.

There's no Skills section. In Claude, turn on code execution. In ChatGPT, your plan or workspace may not include skills yet. In Gemini, the rollout may not have reached your account, or Keep Activity may be off.

Using skills from strangers. Anthropic's docs warn that a malicious skill can direct the AI to do things you didn't intend. Only install skills from sources you trust, and read every file first. OpenAI's scan doesn't replace your own review, and it says so.

Limitations of this guide

Nothing here was tried hands-on. It's a careful reading of each vendor's documentation as of October 19, 2026.
Plan access, menu names and limits are changing quickly. ChatGPT's plan eligibility and Claude's description limit currently conflict across official pages.
A skill makes the instructions consistent, not the results. The same file can behave differently in each app and with each model. Claude's own best-practices guide tells you to test with every model you plan to use.

FAQ

Is a skill the same as a Custom GPT or a Project?
No. OpenAI describes skills as reusable workflows for specific tasks, GPTs as custom versions of ChatGPT, and Projects as shared context, files and conversations.

Do I need to code?
No. A skill can be instructions only. All three apps can also help you draft one: Claude and ChatGPT have a built-in skill-creator, and Gemini can create a skill from a chat.

Will a skill uploaded to Claude.ai show up in Claude's API too?
No. Anthropic's docs say custom skills don't sync between claude.ai and the API, so upload them separately.

Do I have to pay?
For Gemini, Google says no subscription is needed. For Claude, the Help Center includes the Free plan, with code execution turned on. For ChatGPT, OpenAI's pages disagree, so check your account.

Wrapping up

The shared SKILL.md format makes it realistic to keep one source file for all three apps. You get there by writing to the strictest rules: a lowercase hyphenated name that matches the folder, a third-person description under 200 characters, and plain instructions with no scripts. Then upload it the way each app expects. Keep the original folder somewhere safe, because Gemini needs a full re-upload to update files, and Claude needs a new ZIP.

You could build other skills the same way, such as one that adapts Japanese posts for English readers (the article "How to Use AI to Translate Japanese Content for English Readers Without Sounding Like a Robot" shows the steps in prompt form).

Sources

All checked on October 19, 2026.