# Sentry publishes its internal agent skills as an installable plugin

> The getsentry/skills repository holds the agent skills the Sentry team uses in its own development, packaged as a Claude Code plugin and as a skills.sh package. Its value is as a worked example of house conventions written down as executable instructions, not as a general purpose agent toolkit.

**getsentry/skills** — Agent Skills used by the Sentry team for development.

- Repository: https://github.com/getsentry/skills
- Stars: 1,084 · Forks: 58
- Language: Python
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/getsentry-skills

## It is a plugin marketplace entry, not a library

The repository is described as agent skills for Sentry employees, following the Agent Skills open format, and it is distributed in two ways. For Claude Code it is a plugin marketplace, installed with two commands:

```bash
claude plugin marketplace add getsentry/skills
claude plugin install sentry-skills@sentry-skills
```

After installation Claude Code is restarted and the skills activate automatically when relevant. The same content is also available through the skills.sh ecosystem with `npx skills add getsentry/skills`, which the README says works with Claude Code, Cursor, Cline, GitHub Copilot and other compatible agents. There is a specific caveat about sparse checkouts: if you use `claude plugin marketplace add --sparse`, you need to include `skills` and `agents` alongside `.claude-plugin`, because the root plugin manifest loads the repository-root `skills/` and `agents/` directories. Getting that wrong produces a plugin that installs and contains nothing, which is an annoying failure to debug later.

## The skill list is mostly about process, not about code

Reading the table of available skills tells you what a company actually wants an agent to do for it. `commit` carries the instruction that it should always be used when committing code changes and that the agent should never commit directly without it, which is the strongest single rule in the repository. `create-branch` creates git branches following Sentry naming conventions. `pr-writer` creates, refreshes and rewrites pull request titles and descriptions following Sentry conventions, and `pr-link-issue` appends a GitHub issue link and its Linear ticket to the current pull request description. `gh-review-requests` fetches unread GitHub notifications for open pull requests where review is requested from a specified team. `iterate-pr` iterates on a pull request until CI passes and actionable review feedback is addressed. The pattern is that a lot of agent work in a company is procedural, and these skills make the procedure explicit rather than implicit.

## Review skills are split by domain and by failure mode

The review family is the most interesting cluster, because the split shows what different kinds of review need. There is a general `code-review` skill that follows Sentry engineering practices, a `security-review` skill for vulnerabilities, and a `gha-security-review` skill for GitHub Actions workflow exploitation vulnerabilities, which is a specific and much less common threat than ordinary application bugs. There are Django-specific ones, a `django-access-review` for access control and IDOR issues and a `django-perf-review` for performance. Then there are two that are not about reviewing code at all: `find-bugs`, which hunts for bugs, security vulnerabilities and code quality issues in local branch changes, and `secret-serialization`, which finds secrets and tokens that leak through generated serialization such as dataclass repr, asdict, model_dump, JSON.stringify, logs and tracing spans. That last one is a good example of a narrowly scoped check that an agent is well suited to, since the list of leak paths is finite and the reasoning is repetitive.

## Some skills are about Sentry's own product surface

A second group is tied to Sentry's product and internal tooling, and it is where the repository stops being a useful example for anyone outside the company. `document-api-endpoint` documents and types a Sentry API endpoint with drf-spectacular OpenAPI schema, involving writing or fixing `@extend_schema` decorators, specifying response TypedDicts, typing parameters, fixing type drift, and promoting an endpoint to PUBLIC, which is a workflow with internal state. `triage-frontend-issues` triages the Sentry `javascript` project queue by archiving non-actionable noise such as third-party libraries, browser quirks, transient 5xx responses and test traffic, using `untilEscalating` and requiring user approval, so it acts on real data. `sred-project-organizer` takes a list of projects and their documentation and organises them into the SRED format for submission, and `sred-work-summary` goes back through a previous year of work to build a Notion document that groups links into projects. These are examples of very specific internal automation, and reading them tells you as much about Sentry's process as about the skill format.

## The skill format itself has a skill

There is a `skill-writer` entry described as the canonical workflow to synthesise, create and iteratively improve agent skills for this repository, which is a neat bit of recursion and probably the most transferable thing in the whole project. A skill is a directory under `skills/` containing a `SKILL.md` file, and the table links directly to those files, so the format is legible from the repository tree alone. Two other skills are meta in a useful way. `prompt-optimizer` optimises prompts with evals, model-family adapters and exact external context references, and `skill-scanner` scans agent skills for security issues, which is a reasonable thing to run over a third party skill collection before installing it. There is also `claude-settings-audit`, which analyses a repository to generate recommended Claude Code `settings.json` permissions, and `agents-md`, which creates and maintains concise, reference-backed AGENTS.md and CLAUDE.md files.

## Two subagents, and a mirrored directory for tooling

The subagent list is short. `code-simplifier` simplifies and refines code for clarity, consistency and maintainability while preserving all functionality, and appears both as a skill and as a subagent. `senpai` is a senior engineer and technical mentor for new Sentry hires that explains infrastructure, architecture and engineering concepts step by step with references. The repository structure explains the rest of the layout, with a `.claude-plugin/` directory holding the marketplace manifest and the root plugin manifest for sentry-skills, an `.agents/` directory containing a `skills` symlink to the top level `skills` directory described as a local mirror for agent tooling, the `agents/` and `skills/` directories themselves, an `AGENTS.md` for agent-facing documentation, and a `CLAUDE.md` that is a symlink to it. That symlink arrangement is a small thing that saves duplication, and the root also carries a `warden.toml` and a `.claude/` directory.

## Local development and the boundary of the project

Contributing works the way the plugin install does, with a local path instead of a remote one:

```bash
git clone git@github.com:getsentry/skills.git ~/sentry-skills
claude plugin marketplace add ~/sentry-skills
claude plugin install sentry-skills
```

The README also points out that the repository is not the place to look for help setting up Sentry itself or debugging production issues, which is handled by a separate sentry-for-ai repository, so the scope here is deliberately the internal development workflow. The project is published under the Apache-2.0 licence with the licence file at the root, has no GitHub releases, and the last push to the main branch was on 2026-10-15. Taken as a whole, the repository is best read as a published example of house style: the writing standards for the engineering blog, the brand guidelines for copy, the presentation creator for slides, the doc co-authoring workflow and the security review practice all live here, and each is a short document that says what a good answer looks like at that company.

## Conclusion

Adopt the Sentry skills repository if you want a worked example of how a company encodes its engineering conventions as agent instructions, since the skills are concrete and the install path is two commands. Do not adopt it as a general purpose assistant toolkit, because most of the skills reference Sentry specific systems such as Linear, Notion, the Sentry API and its internal project queues. Verify first which of the skills depend on credentials or internal tooling you do not have, and read the `skills/commit` skill's instruction that commits must always go through it before you enable anything that touches your git history.

## FAQ

### How do I install the Sentry skills in Claude Code?

Run `claude plugin marketplace add getsentry/skills` and then `claude plugin install sentry-skills@sentry-skills`, and restart Claude Code. The skills then activate automatically when relevant.

### Can I use the getsentry/skills with agents other than Claude Code?

Yes, through the skills.sh ecosystem with `npx skills add getsentry/skills`. The README says this works with Claude Code, Cursor, Cline, GitHub Copilot and other compatible agents.

### What does a skill look like in the getsentry/skills repository?

Each skill is a directory under `skills/` containing a `SKILL.md` file, and the README table links to those files directly. The repository also has a `skill-writer` skill that is the canonical workflow for creating and improving skills in the repository.

### Which skills depend on Sentry internal systems?

Several, including the ones that touch Linear tickets in pull request descriptions, Notion for the SRED work summary, the Sentry API endpoint documentation workflow, and the frontend issue triage skill that works on the Sentry javascript project queue. They are of limited use outside the company.

### What licence is getsentry/skills released under?

The project is under the Apache-2.0 licence, with the licence text in the LICENSE file at the root of the repository.

## Sources

- [getsentry/skills on GitHub](https://github.com/getsentry/skills)
- [Issues](https://github.com/getsentry/skills/issues)
- [License: Apache-2.0](https://github.com/getsentry/skills/blob/main/LICENSE)
- [README](https://github.com/getsentry/skills/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/getsentry-skills