HumanLayer Skills

HumanLayer skills

Seven HumanLayer skills for Claude Code and Codex: the rpi research, design and implementation loop, visual PRs, CLAUDE.md rewrites and agentic loops

  • 5,433 ★ on the repository
  • Last commit
  • MIT
Skill

Extended access

Why this level

  • The skills write documents into task folders and edit project code
  • visual-pr creates or updates a pull request, and the loop skills add GitHub Actions workflows
All reasons and checks

humanlayer/skills

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/humanlayer-skills

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The skills write documents into task folders and edit project code
  • visual-pr creates or updates a pull request, and the loop skills add GitHub Actions workflows

This is third-party code. Review the repository files before installing.

What it does

A set of seven skills installed one at a time with npx skills add. The main one, rpi, takes a task through code research, a design discussion, a PRD followed by TDD or a technical design, and implementation from local documents; each phase runs in a fresh session by default. show-me explains a topic with short diagrams and HTML artifacts, and visual-pr creates or updates a pull request with a visual outline for the reviewer. improve-claude-md rewrites your CLAUDE.md so the agent follows instructions more closely, and narrow-react-prop-types narrows React prop types to the states live code actually uses. build-iterated-agentic-loop and design-control-loop build a skill and a scheduled GitHub Actions workflow for an agent.

Who it is for. For developers running large changes in Claude Code or Codex who want a structured process with documents at every step.

Good fit when

  • Before changing an unfamiliar module you need to research how collections connect to the database
  • A change needs a PRD and a technical design and you want to walk through them step by step
  • You need a pull request with a visual outline of the change for the reviewer
  • CLAUDE.md has grown and the agent skips some rules
  • You want a scheduled agentic loop on GitHub Actions with a memory file

Not a fit when

  • A two-line fix: the full rpi cycle takes longer than the change itself
  • You want a ready workflow with TDD and debugging skills: Superpowers covers that
  • The Codex sandbox is read-only for .agents and you cannot change permissions
  • The project is not on GitHub: visual-pr and the Actions loops assume GitHub

Example request

/rpi research how the collections connect to the database

Limitations

The rpi skill saves documents under .agents/artifacts by default, and the Codex sandbox can make that folder read-only. Then grant the session write access or pass another task folder such as artifacts/my-change. rpi is invoked explicitly by name: $rpi in Codex and /rpi in Claude Code. The skills are built on the skills.sh CLI. The repository lists no separate key requirements, but the GitHub Actions loops create workflow files that later run in your repository.

How to disable. Delete the folder of the skill you want from the agent's skills directory. If a skill created a GitHub Actions workflow, remove that file from .github/workflows separately.

FAQ

How do I install the HumanLayer rpi skill?

Run npx skills add humanlayer/skills --skill rpi. Then call /rpi with a task or a step such as /rpi make a PRD.

What does rpi do step by step?

It researches questions about the code, discusses the design with you, prepares a PRD followed by TDD or a technical design, then implements from the task's documents. You choose the flow at the start.

How do I invoke rpi in Codex?

With $rpi instead of /rpi. The Codex sandbox can make .agents read-only; grant write access to .agents/artifacts or pass another folder.

What does improve-claude-md do?

It rewrites your CLAUDE.md using tag blocks so the agent follows instructions more closely.

What does build-iterated-agentic-loop build?

A repo-local skill, a scheduled GitHub Actions workflow for a coding agent, a prompt, a memory file and reference templates.

Discussion

No questions or reviews yet.

Skills

Claude Code Skills and Agents

Claude Code Skills & Agents

A Claude Code plugin bundling skills and sub-agents: deep research, image generation, GitHub work, code review and model switching

PluginBroad access1.7KRepository stars

Ready infrastructure for Claude Code: skill auto-activation via hooks, a skill set, agents, slash commands and a wizard that installs it into your project

SkillExtended access10KRepository stars

A set of Claude Code utilities: background skills, expert agents, slash commands and prompt templates for development

SkillExtended access783Repository stars

67 skills across languages, frameworks, DevOps and security, plus 9 workflow commands for Jira and Confluence epics

SkillMinimal access12KRepository stars

A Claude Code plugin: 39 commands for PRs, review, commits and specs, nine expert roles and hooks, in eight language versions

PluginBroad access1.1KRepository stars

ClaudeKit Skills

ClaudeKit - Agent Skills

A plugin marketplace for Claude Code with a set of thirty-plus skills: frontend, backend, devops, databases, documents, debugging and MCP work

PluginExtended access2.2KRepository stars

README in short

The repository opens with a line on installation: every skill installs with npx skills add and the --skill flag. Then rpi, show-me, visual-pr, improve-claude-md, narrow-react-prop-types, build-iterated-agentic-loop and design-control-loop are listed in order. Each has a short description and a call example. For rpi there is a note about Codex and write access to .agents.

README badge

Original SKILL.md

---
name: rpi
description: Only use when the user explicitly invokes this skill by name.
---

# Research, Design, and Implement

Help the user research a change, work through its design, and implement it. Follow their requested step, using the phase instructions below.

`$SKILLBASE` means the directory containing this `SKILL.md`.

`<rpi-invocation>` in templates means the host's skill command: `$rpi` in Codex, `/rpi` in Claude Code, or its plugin-qualified name when the host exposes one. Render next commands with that native invocation.

## Choose the Step

Follow the user's requested step. Read `$SKILLBASE/references/workflow.md` when choosing or explaining a flow or what comes next.

For a task description with no requested step, start with research questions. Ask which flow the user wants: research followed by design discussion, PRD, or TDD, or research only. Wait for their choice before starting the phase, then carry it into suggested next commands.

When asking the user to choose a flow, read `$SKILLBASE/references/workflow-choice.md` and show its box-and-line chart with the question.

Create writes a new document; iterate updates an existing document in place using the user's feedback or resumes the workflow for a partially finished document.

Load the matching process from `$SKILLBASE/references/<step>/process.md`:

| Request | Step |
| --- | --- |
| Research questions | `create-research-questions` or `iterate-research-questions` |
| Research | `create-research` or `iterate-research` |
| Design discussion | `create-design-discussion` or `iterate-design-discussion` |
| Product requirements / PRD | `create-prd` or `iterate-prd` |
| Technical design / TDD | `create-tdd` or `iterate-tdd` |
| Implementation outline | `create-structure-outline` or `iterate-structure-outline` |
| Implement | `implement-outline` |
| Implementation feedback or fixes | `iterate-implementation` |

Update an existing document by default; create one when needed or requested. When several match, use the newest and name the chosen file.

## Use the Task Directory

Use the directory supplied by the user.

Otherwise, look for existing task directories in `.agents/artifacts/` whose names and workflow filenames match the request or current task branch. Reuse an obvious match without asking. If a directory looks close but could belong to a different task, or several directories look plausible, ask the user which to use before writing. Read only documents allowed by the selected phase when checking a match.

When no existing directory fits, use `.agents/artifacts/<branch-name>` with `/` replaced by `-` if the branch identifies the task. On `main`, or when no branch identifies the task, choose a short kebab-case slug from the request and use `.agents/artifacts/<task-slug>` without asking for approval. State the selected path and reuse or create the directory as needed.

Save at the selected path. If the sandbox blocks writes there, ask for scoped write access or a writable task directory and wait for the user's choice.

The RPI framework authors recommend not committing the artifacts.

Number new workflow documents using the next available `NN-` prefix in the task directory. Keep the existing path when updating a document. Save supporting mockups and diagrams beside the documents and link them as ordinary local files.

Workflow document frontmatter includes `repos`, a list of zero or more repositories with `identifier` and `sha` for each entry. Use `repos: []` when none apply. Quote string values as needed for valid YAML.

## Suggest the Next Step

Use the phase's handoff instructions and `$SKILLBASE/references/workflow.md` to choose what comes next. Users run each phase in a separate context window by default. When suggesting a next command, include the task directory and chosen flow. Say they can run it here, after compaction, or in a new session.

Use artifact filenames to locate the current phase when asked what's next, then read its document for unfinished work and settled choices. Recognize `prd` or `product-requirements`, `tdd` or `tech-design`, and `structure-outline` or `outline`.

Report a problem

Foxx AIHumanLayer Skills
Foxx AI

I am Foxx AI and I have already vetted this tool. Ask about install, setup or anything else, and I will keep it simple.