Q&A: skills and commands

These side questions help when you adapt skills and commands to your own agent.

Skill selection

Q: How do you decide what belongs in a skill instead of relying on the model's existing knowledge?

Most general knowledge is already inside the model. A skill is useful when you have a preferred way to do something and you do not want to steer the agent through that path every time.

The practical flow is: work with the agent, correct its approach, arrive at a result you like, then ask it to save those steps as a skill. Next time, the agent can load the saved instructions instead of rediscovering the process.

Course management is a concrete example. If you have an internal API for creating course projects and homework, the model does not know that API by default. A skill can document how to call it, what JSON shape to send, and which curl commands to use.

Skill loading

Q: Where does the skill instruction run?

It runs locally in the runner, exactly like a normal tool call. The model sees the skill list in the prompt, decides that hello is relevant, and asks to call the skill tool with name="hello".

Then Python runs SkillsTool.skill("hello"), loads the file from disk, and adds the tool result to the message history. The next model call sees the skill content and answers according to it.

Skills versus commands

Q: Where do you draw the line between skills and commands?

Skills are implicit from the user's point of view. The user can say "hello" or "I need to deploy my app" without knowing which skill exists. The agent decides whether a skill matches.

Commands are explicit. The user types /kid, /review, or /test because they want that exact reusable prompt. The system should not need to infer which command to use.

Skills versus tools

Q: Are skills normal tool calling?

Yes. In this workshop, a skill is loaded through normal tool calling. The part that makes it useful is lazy loading: the prompt includes the skill names and descriptions, not every full skill body.

This keeps context smaller. The full markdown is added only when the model chooses a matching skill.

Model support

Q: Which models support skills?

Any model that supports tool calls can support this style of skills. We use gpt-4o-mini in the notebook to keep cost low and make how it works visible. A stronger model may follow the instructions more reliably, but the tool-calling flow is the same.

Q: Are Claude models fine-tuned for skills?

Claude Code and the Claude models are closed, so treat their internal training as unknown. The important visible behavior is tool calling. If a model is good at tool calling, it can use this skill pattern.

Reliability

Q: Have you seen 100 percent conformance to skill steps being executed?

The workshop does not include a benchmark. In practice, when a skill should apply, the agent usually loads it. Treat that as experience, not a measured guarantee.

If skill adherence matters, test it like the prototype does: look at the recorded tool calls and assert that the expected skill call happened.

Command discovery

Q: Do we send an explicit list of commands in the system prompt?

The notebook version does not. It gives the model generic instructions: when you see /command, call execute_command with the command name. If the command does not exist, the tool returns Command not found.

For skills, the list matters because the agent has to infer when a skill is useful. For commands, the user already selected the command by typing the slash syntax.

Hot-loading commands

Q: Can commands be hot-loaded?

In the Claude Code demo, restart the session with claude -c after fetching the command files so Claude can discover them.

For your own agent, hot loading is an implementation choice. If the command loader reads from disk on every command run, newly added files can be available immediately. If you cache command lists at startup, you need a reload step.