# skills.sh Integration vs Native Cursor and Codex Plugins: A Technical Deep Dive

> Compare skills.sh integration with native Cursor and Codex plugins. Understand the technical differences and choose the best approach for your AI development workflow.

- Repository: [JetBrains/go-modern-guidelines](https://github.com/jetbrains/go-modern-guidelines)
- Tags: deep-dive
- Published: 2026-08-30

---

**The [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) integration exposes Go Modern Guidelines through a portable CLI wrapper, while native plugins embed directly into Cursor, Codex, and Claude via agent-specific [`plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin.json) manifests.**

The JetBrains/go-modern-guidelines repository distributes its Go best-practices engine through two distinct channels. While both deliver the same compiled rules from the bundled `skills/` directory, they differ fundamentally in installation mechanism, runtime coupling, and agent compatibility. Understanding how the [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) integration differs from native plugin integrations helps teams select the appropriate deployment strategy for their AI-assisted development workflows.

## Native Plugin Architecture

The repository ships three first-class plugins located in the `plugin/` directory, each targeting a specific agent runtime through a declarative manifest pattern.

### The plugin.json Manifest Structure

Native integrations rely on a [`plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin.json) file that agents consume automatically during startup. For Cursor, this manifest resides at [`plugin/.cursor-plugin/plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin/.cursor-plugin/plugin.json):

```json
{
  "name": "modern-go-guidelines",
  ...
  "skills": "./skills/"
}

```

The Codex variant follows the identical pattern in [`plugin/.codex-plugin/plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin/.codex-plugin/plugin.json), referencing the same local `skills/` folder containing compiled rules and assets. When the agent initializes, it parses this manifest, registers the skills, and makes the guidelines available in-editor without manual CLI intervention. The Claude plugin at [`plugin/.claude-plugin/plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin/.claude-plugin/plugin.json) operates on the same principle.

### Agent-Specific Deployment

Because these native plugins embed directly into the agent's extension store, they execute within the host's native plugin loading path. This yields tight IDE integration, automatic updates through the agent's marketplace, and zero external dependencies. The guidelines become available immediately when the IDE loads the plugin, operating as a first-class extension within the Cursor, Codex, or Claude ecosystem.

## The skills.sh Runtime Model

In contrast to the embedded approach, the [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) integration functions as a universal, language-agnostic installer. It does not rely on [`plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin.json) manifests or agent-specific extension APIs, instead using a thin wrapper that forwards skill calls to any compatible LLM agent.

### CLI-Based Registration

Instead of placing files in a plugins folder, developers invoke the [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) runtime through npx commands. To register the guidelines for agents like Junie or custom LLM tools, execute:

```bash
npx skills add JetBrains/go-modern-guidelines

```

This command registers the repository under the generic [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) protocol, making the guidelines available to any agent that understands how to call the `use-modern-go` skill. The runtime discovers the skill via the repository name supplied to the CLI, requiring no local manifest file in the working directory.

### Update and Version Control

Unlike native plugins that update through IDE marketplaces, [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) skills require explicit CLI updates. Pull the latest version with:

```bash
npx skills update use-modern-go -p -y

```

The `-p` and `-y` flags automate the application of changes, ensuring CI pipelines and local environments stay synchronized without manual IDE interaction. This explicit versioning provides deterministic control over which guideline version is active, though it introduces a manual step absent from the native plugin workflow.

## Key Differences Between Native Plugins and skills.sh

The architectural divergence creates distinct operational characteristics across five critical dimensions.

**Installation Method**
- **Native plugins**: Agent-side plugin loading via extension store or manual placement in the agent's plugins folder at paths like `plugin/.cursor-plugin/`. No external CLI required.
- **skills.sh**: Command-line registration using `npx skills add`. Requires Node.js runtime and network access to resolve the repository.

**Manifest Discovery**
- **Native plugins**: Explicit [`plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin.json) with a `"skills"` field pointing to the local `skills/` directory relative to the manifest.
- **skills.sh**: Runtime discovery via repository identifier. No local manifest required.

**Target Agent Scope**
- **Native plugins**: Specific to the host (Cursor, Codex, or Claude). Each plugin targets exactly one agent ecosystem as defined in its respective subdirectory.
- **skills.sh**: Universal protocol compatible with any LLM-powered tool supporting the [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) standard, including Junie and proprietary agents.

**Update Mechanism**
- **Native plugins**: Automatic or marketplace-driven updates managed by the host IDE when the [`plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin.json) and bundled assets refresh.
- **skills.sh**: Explicit version pinning and updates through `npx skills update` commands, decoupled from IDE marketplace schedules.

**Runtime Overhead**
- **Native plugins**: Direct execution within the agent's process space, minimizing latency and context-switching.
- **skills.sh**: Thin wrapper architecture introduces slight indirection but maximizes portability across different editor environments and automated pipelines.

## When to Use Each Approach

Select **native plugins** when standardizing on Cursor, Codex, or Claude for daily development. This approach leverages the agents' built-in plugin ecosystems as implemented in the JetBrains/go-modern-guidelines repository, providing seamless in-editor integration without additional CLI tooling.

Choose **[`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) integration** when operating heterogeneous agent environments, building custom LLM tools, or requiring programmatic control over guideline versions in CI/CD pipelines. The CLI-driven model enables the same Go standards to enforce rules across Junie instances, remote development containers, and automated code review bots that do not support native IDE plugins.

## Summary

- **Native plugins** embed via [`plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin.json) manifests in `plugin/.cursor-plugin/`, `plugin/.codex-plugin/`, and `plugin/.claude-plugin/` directories, offering tight IDE integration for specific agents.
- **[`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) integration** provides agent-agnostic distribution through CLI commands (`npx skills add` and `npx skills update`), decoupling the guidelines from any single IDE ecosystem.
- Native integrations update through marketplace mechanisms, while [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) requires explicit CLI updates using the repository identifier.
- The `skills/` directory containing compiled rules serves as the common payload for both distribution methods, ensuring functional consistency regardless of consumption mechanism.

## Frequently Asked Questions

### Can I use both native plugins and skills.sh simultaneously?

Yes. Since both methods reference the same underlying `skills/` directory content, you can install the Cursor native plugin while registering the repository via [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) for a custom agent. However, ensure version alignment between the native instance and the CLI-managed skill to avoid conflicting rule interpretations.

### Does skills.sh support offline or air-gapped environments?

No. The `npx skills` workflow requires network connectivity to fetch the repository and resolve updates. Native plugins, once downloaded, operate entirely offline because the [`plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin.json) and bundled `skills/` assets in `plugin/.cursor-plugin/` and sibling directories reside locally within the agent's installation.

### Which method provides faster updates for the Go Modern Guidelines?

Native plugins update automatically when the host agent refreshes its extensions, typically on IDE restart. The [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) approach requires manual invocation of `npx skills update`, giving you explicit control over when changes apply but introducing a manual step in the workflow.

### Are the guidelines content identical between the two methods?

Yes. Both distribution channels consume the same compiled rules from the repository's `skills/` directory. Whether loaded through [`plugin/.cursor-plugin/plugin.json`](https://github.com/JetBrains/go-modern-guidelines/blob/main/plugin/.cursor-plugin/plugin.json) or via the [`skills.sh`](https://github.com/JetBrains/go-modern-guidelines/blob/main/skills.sh) runtime, the underlying Go best-practices engine and rule definitions remain functionally identical.