# Agent skills for Claude Code, Codex and Gemini CLI: examples, bundled skills and your own

> Claude Code skills, and agent skills in general, are folders with a `SKILL.md` file of instructions that an agent loads when a task matches the skill's description. Tallos ships seven skills that teach agents to drive Tallos and installs them automatically, offline, into the coding agents it detects on first launch, repairing them on later launches. Skills you already use keep working.

- Canonical: https://runtallos.com/features/agent-skills
- Português: https://runtallos.com/pt/recursos/skills-de-agentes.md
- Author: [Roberto Rocha](https://www.instagram.com/robertorochamkt/)
- Updated: 2026-09-30
- Section: Features

## Key facts

- A skill is a folder with `SKILL.md`: name, description, instructions
- 7 bundled Tallos skills, installed offline on first launch
- Missing or outdated copies repaired on later launches
- **Install now** / **Reinstall** in Settings → General → Agent skills
- Skills from other sources are never touched

## What is an agent skill?

An **agent skill** is a folder that contains a `SKILL.md` file: YAML frontmatter with a `name` and a `description`, followed by Markdown instructions. The folder can also hold scripts, templates or reference files that the instructions point to. [Claude Code](https://runtallos.com/integrations/claude-code), [Codex](https://runtallos.com/integrations/codex), [Gemini CLI](https://runtallos.com/integrations/gemini-cli) and other agents read skills from known folders on your computer or in your repo.

Skills load on demand. The agent sees each skill's name and description up front and reads the full instructions only when a task matches, so a long list of skills costs little until one is needed. That makes the description the most important line in the file.

**Instructions in a prompt**
- You paste them again every session
- The whole text sits in context from the start
- Hard to share and keep consistent across a team

**Instructions in a skill**
- Loaded when the task matches the description
- Only the name and description are read up front
- A folder you can commit, copy and review like code

## What do real skills look like? Examples from Tallos

Tallos ships seven skills inside the app. Each one does a single job and has a description that says exactly when to use it, which makes them useful examples of how to scope a skill.

| Skill | What it does | When the agent reaches for it |
| --- | --- | --- |
| `tallos-cli` | Operates Tallos worktrees, terminals, repos, automations and the built-in browser through the `tallos` command | "Hand this off to another agent", "spawn Codex in a worktree", "read that terminal" |
| `orchestration` | Coordinates supervised workers: task dispatch, threaded messages, blocking questions, decision gates | Splitting work across several agents and supervising them |
| `tallos-linear` | Works from a Linear ticket through the Tallos CLI: read, move state, comment, attach the PR, create follow-ups | Starting or finishing work on a linked Linear issue |
| `tallos-emulator` | Drives a booted iOS Simulator on macOS from the Tallos emulator pane | An iOS change needs simulator evidence |
| `tallos-emulator-android` | Drives an Android emulator or device over adb | Testing an Android build on macOS or Windows |
| `tallos-per-workspace-env` | Sets up and debugs a per-workspace environment recipe: cloud sandbox, VM, SSH host or local container | Each workspace needs its own disposable runtime |
| `computer-use` | Operates visible native app windows through the accessibility tree | A GUI task that no CLI, API or file edit can reach |

_Skills bundled with Tallos_

The `orchestration` skill is what lets one agent coordinate others, the same machinery the leader uses in [squads](https://runtallos.com/features/squads). Tallos also ships `linear-tickets`, the older name of `tallos-linear`, so installs made under that name keep resolving.

The installed files are short on purpose: they tell the agent when to use Tallos, then load the full, version-matched guide from the `tallos` command. How that works, and every command group, is on the [tallos CLI and skills page](https://runtallos.com/features/tallos-cli-and-skills).

## How does Tallos install skills into Claude Code, Codex and Gemini CLI?

Automatically and offline. Shortly after the app starts, Tallos detects the coding agents installed on your computer and copies its bundled skills into each one's global skills folder. Nothing is downloaded: no `npx`, no repository clone.

- **First launch:** installs every bundled skill for each detected agent.
- **Later launches:** repairs skills that went missing, and reinstalls when a Tallos update changes the bundled skills or when a newly installed agent is detected.
- **No agent yet:** nothing is written. Install an agent, then click **Install now** or let the next launch pick it up.
- **Failures retry:** a skill that fails to install is tried again on the next launch.
- **Local edits survive the automatic pass:** it never discards changes made to an installed copy. **Reinstall** replaces modified copies of Tallos's own skills with the shipped version.

| Agent | Global skills folder |
| --- | --- |
| Codex and agents that read the shared folder | `~/.agents/skills` |
| Claude Code | `~/.claude/skills` |
| Gemini CLI | `~/.gemini/skills` |
| Grok | `~/.grok/skills` |

_Where Tallos places its skills (`~` is your home folder, `%USERPROFILE%` on Windows)_

## How do I reinstall or check Tallos skills?

Open Settings → General and find **Agent skills** in the Tallos CLI section. **Install now** appears when the skills aren't detected and **Reinstall** once they are; both run the same offline install. **Re-check** refreshes the status.

If no coding agent is detected, Tallos tells you to install one, such as Claude Code or Codex, and try again. [Connect your agents](https://runtallos.com/learn/connect-your-agents) walks through that. The one-click install writes to this computer; for a remote runtime, Tallos keeps a terminal-based install instead.

## Give your agents Tallos skills

> Install Tallos and your agents get its skills on first launch. No setup step, no download. → https://runtallos.com/signup

## How do I write my own Claude Code skill?

Create a folder, add a `SKILL.md` with a clear name and description, and put it where your agent reads skills. For Claude Code, that is `~/.claude/skills/<name>/` for a personal skill or `.claude/skills/<name>/` inside a repository to share it with your team.

1. **Pick one job** — A skill should do one thing well: draft release notes, follow your migration conventions, triage a flaky test. Split broad topics into several skills.
2. **Create the folder** — Name it in lowercase with hyphens, for example `release-notes`, and use the same value for `name` in the frontmatter.
3. **Write the description first** — The agent decides when to load the skill from its description. Say what it does and when to use it, with the words people actually type: "release notes", "changelog", "what shipped".
4. **Keep the instructions short** — Numbered steps, exact commands and what to avoid. Move long reference material into separate files in the folder and point to them from `SKILL.md`.
5. **Test it in a fresh session** — Start a new agent session and ask for the task in plain words. If the skill doesn't load, sharpen the description.

```markdown
---
name: release-notes
description: >-
  Draft release notes from the commits since the last git tag. Use when
  the user asks for release notes, a changelog entry, or what shipped
  in a version.
---

# Release notes

1. Find the last tag: `git describe --tags --abbrev=0`.
2. List the commits since that tag: `git log <tag>..HEAD --oneline`.
3. Group the changes under Features, Fixes and Internal.
4. Write one plain-language line per change. Skip version bumps.
5. Save the result to `RELEASE_NOTES.md` and show a short summary.
```

Keep a skill in the repo when it encodes team conventions, and in your home folder when it is personal. A skill in `.claude/skills` is committed like any other file, so it exists in every [parallel workspace](https://runtallos.com/features/parallel-workspaces) Tallos creates from that repo.

> **Skills can run code** — A skill can tell an agent to run scripts. Read a third-party skill before you install it, the same way you would read a shell script.

## Do my existing skills keep working with Tallos?

Yes. Tallos only installs and repairs its own bundled skills; skills from other sources are never touched. Agents started in Tallos run as they do in any terminal, so they keep loading every personal and project skill they already know about.

Skills and MCP complement each other. A skill is instructions; an [MCP server](https://runtallos.com/features/mcp) is a tool connection to an outside system. A good skill often tells the agent when to call a specific MCP tool.

## Frequently asked questions

### What are Claude Code skills?

Claude Code skills are folders with a `SKILL.md` file: a name, a description and instructions that Claude Code loads when a task matches the description. A skill can also include scripts and reference files.

### Where do I put a custom skill for Claude Code?

Use `~/.claude/skills/<name>/SKILL.md` for a personal skill, or `.claude/skills/<name>/SKILL.md` inside a repository to share it with everyone who works in that repo.

### Which skills does Tallos install?

`tallos-cli`, `orchestration`, `tallos-linear`, `tallos-emulator`, `tallos-emulator-android`, `tallos-per-workspace-env` and `computer-use`, plus `linear-tickets` as the legacy name of `tallos-linear`.

### Does Tallos need internet access to install its skills?

No. The skills ship inside the app and are copied into your agents' skills folders offline, with no `npx` and no repository download.

### Will Tallos overwrite or delete my own skills?

No. Tallos manages only its own bundled skills. The automatic pass on launch never discards local edits; only **Reinstall** replaces modified copies of Tallos's own skills.

### What happens if I install a new agent after Tallos?

On the next launch Tallos detects the new agent and installs its skills there too. You can also click **Install now** or **Reinstall** under Settings → General → Agent skills.

### What is the difference between a skill and an MCP server?

A skill is a set of instructions the agent reads; an MCP server is a program or endpoint that gives the agent new tools. Many setups use both.

## Sources

1. [Agent Skills overview](https://agentskills.io/home) — Agent Skills (open standard)
2. [Extend Claude with skills](https://code.claude.com/docs/en/skills) — Anthropic
3. [Skills & plugins](https://learn.chatgpt.com/docs/skills-and-plugins) — OpenAI
4. [Agent Skills in Gemini CLI](https://geminicli.com/docs/cli/skills/) — Google

---

**Run your agents in parallel with Tallos** — Claude Code, Codex, Gemini and 30+ agents — each in its own workspace, with squads, chat, terminals and review in one app. Uses the subscriptions you already have.

https://runtallos.com/signup (macOS 13+ · Windows 10+)