Skip to main content
skill CX Codex

agent-interface-design — Claude Code skill: interfaces agents can read

A skill for designing tools, scripts and CLIs that an agent calls, so the interface explains itself. Useful when you build an MCP server or an agent keeps misusing a tool it already has.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Neeeophytee/finding-unknowns-skills --skill agent-interface-design -a claude-code
Open on GitHub

What agent-interface-design does

The skill treats a tool interface as the first place mistakes come from. Step one is finding out how the tool is actually being misused: read transcripts, logs, or the complaint itself. Misuse points at the interface before it points at documentation, and the usual fix is a rename or a type rather than another paragraph.

Meaning then moves into the parameters. An enum such as pending | in_progress | completed carries the whole state machine with no prose at all. Parameters get named for intent, not implementation. Where the type system allows it, invalid states become impossible to express. Behavioral guidance belongs in the tool's own description, at the point of use, and nowhere else — restating it in a global preamble is how a codebase ends up contradicting itself.

Wanting to add a usage example is a signal worth reading: it usually means a parameter is underspecified, so fix the interface first. Keep an example only for a format nobody could guess, like a bespoke query syntax. The skill also asks you to sort tools by how often they are needed — resident in context versus discoverable on demand. It closes by naming the mistake the design still permits and judging whether that is cheap enough to live with. Irreversible, high-stakes operations are the exception: explicit confirmation beats elegance, and no signature changes before every existing caller is found.

What it helps with

  • rewrite tool parameters so the agent calls them correctly
  • strip prose from a tool description that duplicates global instructions
  • trace why an agent keeps misusing a tool it already has
  • decide which tools stay in context and which load on demand
  • check every existing caller before changing a signature

Example prompts for the agent

  • Read the call logs and tell me why the agent keeps misusing this tool
  • Redesign this MCP tool's description and parameters with the agent-interface-design skill
  • Review this signature: what mistakes does it still allow, and do we need a guardrail?

How to install agent-interface-design

1Skills CLI (Vercel)

npx skills add Neeeophytee/finding-unknowns-skills --skill agent-interface-design -a claude-code

2Manually: put the files in place

~/.claude/skills/agent-interface-design/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/agent-interface-design/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about agent-interface-design

How do I install agent-interface-design in Claude Code?

Run npx skills add Neeeophytee/finding-unknowns-skills --skill agent-interface-design -a claude-code. The skill lands at ~/.claude/skills/agent-interface-design/SKILL.md.

What does agent-interface-design do?

It guides the design of tools, scripts and CLIs an agent will call, pushing meaning into parameters and descriptions instead of examples and long prose.

Which platforms support this skill?

Claude, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode, each with its own install path. There is also a path for Windsurf (Devin Desktop).

Source text

SKILL.md · MIT
---
name: agent-interface-design
description: Design tools, scripts, and CLIs that an agent will call, so the interface teaches its own use instead of a wall of prose and examples. Use when building an MCP server or tool definition, writing an agent-facing script, or when an agent keeps misusing a tool it already has.
---

# Agent interface design

Examples teach one path and quietly fence off the others: shown three ways to call a tool, a model tends to produce those three. A well-designed interface teaches the whole space at once. The parameters say what is possible, the description says what is expected, and there is very little left to write.

## Steps

1. Find out how the tool is actually being misused before redesigning it. Read transcripts, logs, or the user's complaint. Misuse is an interface symptom first and a documentation symptom second, and the fix is usually a rename or a type, not a paragraph.
2. Push meaning into the parameters:
   - Enumerate instead of accepting free text. A status of `pending | in_progress | completed` teaches the whole state machine without a sentence of prose.
   - Name for intent rather than implementation, so the right call is the one that reads correctly.
   - Make invalid states unrepresentable wherever the type system allows it. A parameter that cannot express a mistake needs no warning about that mistake.
3. Put behavioral instruction in the tool's own description, at the point of use, and only there. The same guidance restated in a global preamble is how a codebase grows contradictions.
4. Treat the urge to add a usage example as a diagnostic: it usually means a parameter is underspecified. Fix the interface first. Keep an example only for a format that genuinely cannot be guessed, such as a bespoke query syntax.
5. Decide what is resident and what is discoverable. Tools needed on most turns belong in context; tools needed rarely should be findable on demand so they cost nothing until they're wanted.
6. Finish by naming the mistake the design still permits, and say whether it is cheap enough to live with or needs an explicit guardrail.

## Guardrails

- A description that has to explain what a parameter means is a parameter that needs a better name.
- Irreversible and high-stakes operations are the exception to all of the above: there, explicit constraint and confirmation beat elegance.
- Never redesign a signature without first finding every existing caller.
- Terseness is not the goal; expressiveness is. Cutting a description that carried real behavior is a worse outcome than a description that ran long.

© Neeeophytee · MIT · Neeeophytee/finding-unknowns-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set5

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor