Skill Exposure Differences Between Skills CLI and Claude Code Users

The Skills CLI exposes skills directly from the repository with automatic discovery and always-latest versions, while Claude Code users access the identical skill set through a versioned plugin requiring explicit installation and prefixed command syntax.

The jakubkrehel/skills repository distributes UI-related automation capabilities through two distinct channels. While both the Skills CLI (npx skills) and the Claude Code plugin provide access to the same underlying functionality, the skill exposure architecture differs fundamentally in how users discover, update, and invoke these capabilities.

Installation and Environment Setup

The initial setup process establishes the foundation for how skills are exposed to each environment.

Skills CLI users install the entire skill set locally by running:

npx skills add jakubkrehel/skills

This command pulls the complete repository into the local environment, making all skills immediately available. According to the source code in README.md, this single command enables access to the entire collection without additional configuration.

Claude Code users must install through the plugin marketplace using:

/plugin install interfaces@interfaces

As defined in .claude-plugin/plugin.json, this registers a single entry point (interfaces) rather than individual skills. The plugin version field (currently 1.6.3) determines exactly which snapshot of skills is exposed to the user.

Skill Discovery Mechanisms

The discovery architecture determines how new capabilities become visible to users.

Automatic Discovery in CLI

The Skills CLI implements automatic discovery by scanning the skills/ directory. Any new skill directory added to the repository becomes instantly callable as a slash command—such as /better-typography—without requiring manifest updates or redeployment. The CLI dynamically enumerates available commands directly from the filesystem structure.

Plugin Registration in Claude Code

The Claude Code plugin exposes skills through a centralized registration system. The plugin.json file defines a single namespace (interfaces), and users access individual skills by prefixing commands with this namespace (e.g., /interfaces:better-typography). Skills are not automatically discovered; they must be included in the bundled plugin version deployed to the marketplace.

Version Control and Update Behavior

Versioning represents the most significant difference in skill exposure between the two platforms.

Always-Latest CLI Approach

Skills CLI users always execute the most recent code available in the GitHub repository. Each invocation pulls directly from the source, ensuring that bug fixes and new capabilities are immediately available without user intervention. This live-update model means the CLI serves as a thin wrapper that forwards requests to the underlying language model using the current repository state.

Version-Locked Plugin Model

Claude Code users are bound to the specific version declared in .claude-plugin/plugin.json. When the repository maintainer bumps the version (e.g., from 1.6.2 to 1.6.3) and publishes to the marketplace, users must explicitly update their plugin to receive new skills or modifications. This creates a stable, predictable skill exposure that does not change unexpectedly between sessions.

Command Invocation Syntax

The practical user experience differs in how commands are structured and executed.

Direct Invocation (CLI)

Skills CLI supports direct slash commands without namespace prefixes:

/better-interface
/variant
/interface-review

Prefixed Invocation (Claude Code)

Claude Code requires the plugin namespace prefix for all skill calls:

/interfaces:better-interface
/interfaces:variant
/interfaces:interface-review

This syntax difference ensures that Claude Code can route commands to the correct plugin when multiple plugins are installed, while the CLI operates as the primary interface.

User-Invoked vs. Model-Invoked Skills

The execution context varies between platforms regarding who initiates the skill.

CLI execution model treats all skills as model-invoked capabilities. The CLI forwards requests to the language model, which determines when to utilize specific skills based on context and user queries.

Claude Code execution model distinguishes between user-invoked and model-invoked skills. Certain skills—such as interface-review and explain-interface—are explicitly marked as user-invoked in their front-matter and in agents/openai.yaml. These flags ensure that specific skills only execute when explicitly requested by the user, providing finer control over the automation workflow.

Summary

• Installation: CLI uses npx skills add for direct repository access; Claude Code requires marketplace plugin installation via /plugin install interfaces@interfaces
• Discovery: CLI automatically discovers skills from the skills/ directory; Claude Code exposes skills through the versioned plugin.json entry point
• Versioning: CLI always uses the latest GitHub code; Claude Code locks to specific plugin versions (e.g., 1.6.3) until manually updated
• Invocation: CLI uses direct commands (/better-typography); Claude Code requires prefixed commands (/interfaces:better-typography)
• Execution: CLI skills are exclusively model-invoked; Claude Code supports both user-invoked and model-invoked skills as defined in agents/openai.yaml

Frequently Asked Questions

How do I update skills in each environment?

Skills CLI users receive updates automatically every time they run a command, as the tool pulls directly from the jakubkrehel/skills GitHub repository. Claude Code users must wait for the maintainer to publish a new plugin version to the marketplace and then manually update using the plugin management interface.

Can I use the same skill files in both environments?

Yes. Both platforms consume the identical skill definitions stored in the repository's skills/ directory. The difference lies in how those files are exposed and invoked, not in the skill logic itself. However, Claude Code requires the additional plugin.json manifest to register the entry point.

Why does Claude Code require prefixed commands while the CLI does not?

Claude Code operates as a multi-plugin environment where multiple skill providers may be installed simultaneously. The /interfaces: prefix namespace prevents command collisions and ensures proper routing to the jakubkrehel/skills plugin. The Skills CLI functions as a dedicated interface, eliminating the need for namespaces.

Which skills are restricted to user invocation in Claude Code?

According to agents/openai.yaml and individual skill front-matter, specific skills like interface-review and explain-interface are configured as user-invoked. This means they only execute when explicitly requested via the /interfaces: prefix command, rather than being automatically triggered by the model during conversation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}