Agent Skills

Agent skills are reusable, user-defined instruction sets that extend Tabnine CLI's capabilities. Each skill provides specialized knowledge, workflows, or domain-specific behaviors that the agent can activate on demand. Unlike TABNINE.md project instructions (which load automatically on every session), skills load only when relevant, keeping the agent's context efficient.

Skill Structure

A skill is a SKILL.md file placed inside a named directory. The file must include a YAML frontmatter block with name and description fields, followed by free-form markdown instructions.

---
name: my-skill
description: A brief description of when this skill should be activated
---

# My Skill Instructions

Detailed procedural instructions go here...

The description field is critical — it determines when the agent will activate the skill. Write it to clearly describe the situations or requests that should trigger it.

Resource files (templates, schemas, reference docs) can be placed alongside SKILL.md in the same directory. When the skill is activated, the agent gains read access to the entire skill directory and can use these files as reference material. Resource files do not need to be declared in frontmatter.

The recommended directory layout follows the Agent Skills convention:

my-skill/
├── SKILL.md          # Required: metadata + instructions
├── scripts/          # Optional: executable code (Node.js, Python, Bash)
├── references/       # Optional: documentation loaded into context as needed
├── assets/           # Optional: templates, icons, fonts, boilerplate
└── ...               # Any additional files or directories

The subdirectory names are a convention, not a requirement. The agent has access to the entire skill directory regardless of how files are organized.

How Skills Work

Skills follow a simple lifecycle. The agent matches a user request to an available skill based on the skill's description. When a match is found, the agent activates the skill using the activate_skill tool, which loads the full instructions and makes the skill's directory contents available as resources. The agent then follows the skill's procedural guidance for the duration of the task.

Skills can also be activated explicitly by asking the agent to use a specific skill by name (for example, "use the code-reviewer skill to review my changes").

Skill Locations

Skills are discovered from multiple locations, listed here from lowest to highest precedence. When skills share the same name, higher-precedence locations override lower ones.

Priority	Scope	Path
1 (lowest)	Built-in	Bundled with the CLI
2	Extension	Provided by installed extensions
3	User (primary)	~/.tabnine/agent/skills/<name>/SKILL.md
4	User (alias)	~/.agents/skills/<name>/SKILL.md
5	Workspace (primary)	<project>/.tabnine/agent/skills/<name>/SKILL.md
6 (highest)	Workspace (alias)	<project>/.agents/skills/<name>/SKILL.md

Workspace-level skills are only loaded when the workspace folder is trusted. If the folder is not trusted, workspace skills are silently skipped.

The skill loader searches each directory for SKILL.md files at the root level or one subdirectory deep (matching the patterns SKILL.md and */SKILL.md).

Managing Skills from the Terminal

The tabnine skills command provides skill management outside of interactive sessions.

# List all discovered skills
tabnine skills list

# Include built-in skills in the listing
tabnine skills list --all

# Install a skill from a Git repository
tabnine skills install https://github.com/user/repo.git

# Install a specific skill from a monorepo subdirectory
tabnine skills install https://github.com/org/skills.git --path skills/frontend

# Install from a local directory
tabnine skills install /path/to/local/skill

# Install from a .skill package file
tabnine skills install path/to/my-skill.skill

# Install to workspace scope instead of user scope
tabnine skills install /path/to/skill --scope workspace

# Link a skill (symlink — edits to the source files are picked up on the next session or after /skills reload)
tabnine skills link /path/to/my-skills-repo

# Link to workspace scope
tabnine skills link /path/to/skills --scope workspace

# Uninstall a skill by name
tabnine skills uninstall my-skill

# Uninstall from workspace scope
tabnine skills uninstall my-skill --scope workspace

# Enable a previously disabled skill
tabnine skills enable my-skill

# Disable a skill (defaults to workspace scope)
tabnine skills disable my-skill

# Disable in user scope
tabnine skills disable my-skill --scope user

The install and link commands accept a --consent flag to skip the interactive security confirmation prompt, which is useful for CI/automation. Both default to user scope.

Managing Skills in Interactive Mode

The /skills slash command provides skill management during an interactive session.

Subcommand	Description
/skills list	Lists all discovered skills with descriptions. Append nodesc to hide descriptions, or all to include built-in skills.
/skills link <path>	Links skills from a local directory via symlink. Accepts --scope user (default) or --scope workspace.
/skills disable <name>	Disables a skill by name.
/skills enable <name>	Re-enables a disabled skill.
/skills reload	Refreshes discovered skills from all locations. Alias: refresh.

Running /skills with no subcommand defaults to list.

Managing Skills with /memory inbox Command

The /memory inbox command opens an interactive dialog for reviewing skills that Tabnine CLI has automatically extracted from your past sessions. From the inbox you can approve a skill (moving it to your global or project skills directory), edit its name and description before saving, or dismiss it.

To open the inbox, run:

/memory inbox

The inbox is part of the experimental memory manager. Enable it by adding the following to your settings:

{
  "experimental": {
    "memoryManager": true
  }
}

If the memory manager is not enabled, /memory inbox will display a message with instructions to enable it.

Skill patching: If a skill with the same name already exists in your skills directory, the inbox will offer to patch it rather than create a duplicate, merging the new content into the existing file.

Disabling Skills

Skills can be disabled through the CLI commands above or by adding the skill name to the skills.disabled array in settings.json.

{
  "skills": {
    "disabled": ["my-skill", "another-skill"]
  }
}

Disabled skills from both user and workspace settings are merged (union strategy). A skill disabled at any scope is disabled everywhere. Enabling a skill removes it from all writable scopes.

Creating a Skill

The easiest approach is to ask the agent directly — Tabnine CLI includes a built-in skill-creator skill that scaffolds well-structured skills. Prompt it with requests like "Create a skill for reviewing database migrations" or "Make a skill that helps write API documentation following our team's format."

To create a skill manually, create a directory with a SKILL.md file containing the required frontmatter, place it in one of the discovery locations, and run /skills reload (interactive) or tabnine skills list (terminal) to pick it up.

Packaging and Sharing Skills

Skills can be packaged into .skill files for distribution. A .skill file is a zip archive containing the skill directory, which can be shared with teammates or published to a registry.

Creating a Package

To package a skill for sharing, ask the agent: "Package my-skill into a .skill file." The built-in skill-creator skill handles scaffolding, validation, and packaging automatically.

Installing a Package

# Install to user scope (default)
tabnine skills install /path/to/my-skill.skill

# Install to workspace scope
tabnine skills install /path/to/my-skill.skill --scope workspace

# Skip the interactive security prompt (useful for CI)
tabnine skills install /path/to/my-skill.skill --consent

After installing, run /skills reload in an active session to pick up the new skill immediately.

Uninstalling

tabnine skills uninstall my-skill

Best Practices

• Write clear, specific descriptions so the agent activates the skill at the right time.

• Structure instructions as step-by-step procedures rather than general guidelines.

• Include concrete examples and templates in resource files when possible.

• Keep each skill focused on a single domain or task type.

• Test skills by asking the agent to perform the relevant task and verifying it follows the instructions correctly.