Posit's skills collection is workflow knowledge, packaged per directory

A skill is activated by the task, not loaded by you

The first thing to understand is the delivery model, because it is not a plugin that adds a command. The documentation describes Agent Skills as an open standard for extending coding agents with specialized knowledge and workflows, and says that skills are automatically activated by your coding assistant based on your task. The point of that sentence is that you do not select a skill from a menu and run it. The assistant decides, from what you asked, that a particular skill applies, and the skill's text is what shapes the answer. The distribution is also deliberately broad, with the documentation saying the skills work across many harnesses, naming Posit Assistant, Claude Code, Codex, Cursor and Cline among them, and pointing Posit Assistant users at that product's own skills documentation. So the unit of value here is not a tool but a written procedure. If your problem is that an assistant keeps producing R code in the wrong style, or keeps missing the release steps for your package, a skill that encodes those specifics is the fix, and a general-purpose prompt is not.

The repository layout is a directory per skill, and the index is a table of contents

The root listing explains the whole structure. There is a directory per subject area, `posit-dev/`, `github/`, `open-source/`, `r-lib/`, `shiny/`, `quarto/`, `ggsql/`, `connect/`, `alt-text/`, `brand-yml/` and `tidyverse/`, and inside each one a directory per skill, each linked from the index with a relative path. Several of the skill links point at a markdown file inside the directory rather than at a file, for example the Quarto authoring entry points at `quarto/README.md#quarto-authoring-skill`, which suggests that some skills are a single markdown document and others are a directory with more. Two supporting scripts sit at the root: `count-skill-tokens.py` and `find-stale-references.py`. Between them they tell you what the maintainers worry about, which is that skills have a token cost and that references between them can go stale. There is also a `.claude-plugin/` directory at the root, a `CONTRIBUTING.md` for people adding to the collection, an `AGENTS.md` for the same audience, and a LICENSE file with the licence recorded as MIT. The repository has no tagged releases, so the collection is tracked by commit rather than by version.

The review skills separate mechanical changes from behaviour changes

The five general-purpose developer skills are the most reusable part of the collection, and the way they are scoped is the interesting part. The `critical-code-reviewer` skill is described as conducting rigorous, adversarial code reviews that identify security holes, lazy patterns, edge case failures and bad practices across Python, R, JavaScript and TypeScript, SQL and front-end code. The word adversarial is doing work there, since a review that only confirms what is already there is worth little. The `r-tidyverse-style` skill is narrower and more careful in an instructive way: it reviews and cleans up R package code using the tidyverse style guide while separating mechanical style changes from behaviour-sensitive refactors. That separation is the part a team should care about, because a style pass that quietly changes behaviour is worse than no style pass. The `review-testing` skill covers assertion completeness, mocking boundaries, fixture design, test smells and coverage gaps after a feature lands, and `describe-design` produces architectural documentation with Mermaid diagrams and stable code references intended to be useful to humans and to agents alike.

The tracking-document pair is a session-to-session memory mechanism

Two of the developer skills form a pair, and between them they solve a problem that anyone using an agent on a long task will recognise. The `new-work` skill creates a todo tracking document for a new feature, bug or task, and keeps it updated with decisions, plans and progress for the rest of the session. The `working-on` skill sets an existing tracking document as the source of truth for the current session, keeping it updated with decisions and progress. The mechanism is a markdown file on disk that outlives the conversation, which means the decisions a model makes at hour one are still available at hour six, and after a context reset or a handoff to a colleague. That is a much more reliable substrate for continuity than asking an agent to remember, and it is also reviewable, since the file can be committed and read by a person who will never open the session transcript. The `describe-design` skill plays a related role for orientation rather than tracking, producing a written description of how a system works.

The GitHub skills close the loop on pull requests

Three skills are grouped under GitHub, and the reason is that pull request work has three distinct shapes that are easy to confuse. The `pr-create` skill creates a pull request from the current changes, monitors GitHub CI, and debugs any failures until CI passes, which is the part that distinguishes it from a one-shot command, since a pull request that is opened and then fails is work in progress. The `pr-threads-address` skill reviews all unresolved review threads, addresses them by making necessary code changes, and commits those changes appropriately, so the reply and the fix travel together. The `pr-threads-resolve` skill bulk resolves unresolved threads, which is the counterpart for feedback that turns out to be not actionable. The value of having these as skills rather than as checklist items in your head is that the model applies them consistently under pressure, when a human is tired and inclined to resolve threads without addressing them. The two open-source skills sit next to this group, covering a release checklist and GitHub issue for an R package with automatic version calculation, and release blog posts following Tidyverse or Shiny blog conventions for both R and Python packages.

The r-lib skills are the deepest part of the collection

Eight skills under `r-lib/` cover the R package ecosystem, and their descriptions are specific enough to show what each one actually does. `r-package-development` covers devtools, testthat and roxygen2, with key commands, coding conventions, testing, documentation and NEWS.md practices. `r-testthat` covers testthat 3 and above, including test structure, expectations, fixtures, snapshots, mocking and BDD-style testing. `r-cli` is about the cli package for command-line interface styling, semantic messaging, user communication, inline markup, progress indicators and theming. `r-lifecycle` manages deprecation workflows, function and argument renaming, superseding and experimental stages following tidyverse principles. `r-cran-extrachecks` prepares packages for CRAN submission by checking for common ad-hoc requirements not caught by `devtools::check()`, with documentation standards, DESCRIPTION field formatting and URL validation named explicitly. `r-mirai` covers async, parallel and distributed computing with explicit dependency passing, daemon setup, parallel mapping with `mirai_map()`, Shiny integration, remote and HPC launchers, and migration from future and parallel. The `alt-text` skill generates and improves accessible alt text for data visualisations and images in pkgdown sites and Quarto documents.

The Shiny, Quarto and ggsql skills are two audiences for the same brand system

The `brand-yml` skill appears under two headings, and that duplication is informative. Under Shiny it creates and applies brand.yml files for consistent styling across Shiny apps, with support for bslib in R and ui.Theme in Python, including automatic brand discovery and theming functions for plots and tables. Under Quarto the same skill is described as supporting HTML documents, dashboards, RevealJS presentations, Typst PDFs and websites, with automatic brand discovery and theme layering. So a single brand file has to survive being applied to an app and to a document, and the skill exists to make that consistent rather than two separate mechanisms. The Shiny group also has `shiny-bslib` for building modern dashboards with Bootstrap 5 layouts, cards, value boxes, navigation, theming and modern inputs, including a migration guide from legacy Shiny patterns, and `shiny-bslib-theming` for comprehensive theming with `bs_theme()`, Bootswatch themes, custom colours, typography, Bootstrap Sass variables, custom Sass and CSS rules, dark mode, dynamic theming and R plot theming. The `ggsql` skill covers writing ggsql queries, described as a grammar of graphics for SQL.

Installing means picking skills, and the documentation does not give one command

There is no install command in the project documentation, and that is worth being explicit about rather than working around. The documentation's own path is the Posit Assistant skills documentation for Posit Assistant users, and the collection is described as a collection of Agent Skills from Posit, with the open standard documented at agentskills.io. The repository ships a `.claude-plugin/` directory, which is the convention for a Claude Code plugin, and each skill lives in its own directory under a subject folder, so a user or an agent that understands the standard picks the ones it needs rather than installing everything. The repository also carries a `CONTRIBUTING.md` and an `AGENTS.md`, so the intended way to extend the collection is by writing a skill that follows the same conventions, and the two root scripts, `count-skill-tokens.py` and `find-stale-references.py`, are there to keep that in check. A team that wants to vendor these skills internally should expect to copy the relevant directories and manage them itself, because there is no versioned package to depend on.

Editorial conclusion

The collection is worth adopting if you work in R or Shiny and already use Posit Assistant or Claude Code, because the skills encode specific procedures rather than general advice, from the separate mechanical and behaviour-sensitive passes in the tidyverse style skill to the CRAN extra checks that devtools::check does not perform. It is a poor fit if you need executable tooling, since a skill is instructions the model reads rather than code it runs, and a poor fit if your team wants one opinion on style, because some of these skills will rewrite your conventions. Before you install it, read the individual skill directories rather than the index, check that the review skills match how your team actually wants to be reviewed, and note that the last push to the repository was on 2026-10-15 with the licence recorded as MIT and no tagged releases.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. posit-dev/skills on GitHub
4. README