# Agent skills

> Every module ships a skill and a handoff note, installed in the layout the coding agent you picked actually reads.

Page: https://sdk.chatfuel.com/docs/concepts/agent-skills
Markdown: https://sdk.chatfuel.com/docs/concepts/agent-skills.md

The wizard's last act is to hand the project to a coding agent, so the app has to arrive with notes
and not only with code. Everything on this page follows from that: the agent that continues the work
needs what we know about the API's edges, and it needs it in the place its own CLI looks.

## One skill per module [#one-skill-per-module]

Each module carries a `skill/` directory in this repository, and the wizard copies it into your
project as `chatfuel-<id>` — `chatfuel-deals`, `chatfuel-livechat`, one per module you picked. Each
one holds that module's structure, its GraphQL operations and the traps in the API behind it.

Beside the copy goes a small sidecar recording the module, the wizard version and the timestamp. That
is what lets a later run tell its own installs apart from a directory you wrote yourself: it names
the version and the date and asks before replacing, and a directory it does not recognise gets a
blunter question.

## Two layouts, because neither CLI reads the other's [#two-layouts-because-neither-cli-reads-the-others]

| Agent       | Instructions file | Skills directory  |
| ----------- | ----------------- | ----------------- |
| Claude Code | `CLAUDE.md`       | `.claude/skills/` |
| Codex CLI   | `AGENTS.md`       | `.agents/skills/` |

Neither reads the other's directory, so this is a choice the wizard has to make rather than hedge.
Copying both layouts would leave two trees to drift apart instead of one to maintain — so the skills
are written once, and moved if the agent you settle on at the handoff is not the one they were laid
out for.

The difference goes one level deeper than the paths. Claude Code loads its skills directory by
itself, so naming the skills is enough. Codex's discovery depends on its version and the user's
config, so its instructions file spells out the full path to each `SKILL.md`.

Skills can also go to your home directory instead of the project, in the same layout — useful when
you will scaffold more than one app and want one copy of the notes.

## The handoff note, and the checklist it lands in [#the-handoff-note-and-the-checklist-it-lands-in]

Two files come out of the run, and they do different jobs.

`CLAUDE.md` or `AGENTS.md` is the standing brief: the routes this app has, the skills to read before
touching the API, which environment variables are secrets that must never be printed, and how to
resume the guided setup later. It is short on purpose — it is read on every session start.

The **setup checklist** is the one-time script for the first session: how to greet you, a tour of the
modules that were installed, the deep links to what was seeded, and the instruction to start the dev
server rather than ask you to. Each module's `handoff.md` is inlined into it verbatim, under a
"Module guides" heading, which is where the module-specific first tasks and gotchas live.

Claude Code reads that checklist as a slash command; Codex reads it as a skill, with the frontmatter
that makes the same text valid in both places. When the wizard launches the agent for you, all it
types is the instruction to run it.

In `--embed` mode the instructions file belongs to a project that already existed, so the wizard
writes a marked section into it and rewrites that section on later runs instead of overwriting the
file.

## What a skill is actually for [#what-a-skill-is-actually-for]

The concrete case: module code is plain React and a typed GraphQL client, and the operations each
module uses live in its skill's examples, validated against the bundled schema. So "add a column to
the deals table" is a sentence rather than a file hunt — the agent already has the operation, the
schema and the note about what that field does when it is null.

That is also why the skills are per module rather than one big document. You installed four modules,
so your agent reads four sets of notes and not thirteen.

This site does the same thing for the same reason. It serves itself as a skill at `/SKILL.md`, and
every documentation page as Markdown — `/docs/concepts/state.md` is this section's neighbour in plain
text — with the whole list at `/docs/llms.txt`.

## What it costs [#what-it-costs]

A skill is a copy, like everything else the wizard writes. It reflects what we knew on the day you
ran it, and it does not update itself — re-running the wizard is what replaces one, after it has
asked. If you edit a skill to match your own changes, note that a later run will offer to overwrite
it.

[Your first change](/docs/first-change) ends with the version of this you can try in one line.
