Warp Rust warpdotdev/warp

.agents/skills: Building a Repo for AI Contributors

How Warp ships SKILL.md files, structured specs, and a contribution flow that lets agents land production code.

6 stops ~18 min Verified 2026-05-04
What you will learn
  • What lives in .agents/skills/ and how a harness loads a SKILL.md by name and description
  • The required YAML frontmatter format and why the description string is load-bearing
  • How specs/GH408/ ties an issue to specific files and line ranges so an agent has the diff frame before writing code
  • How .warp/ and .claude/ extend the same pattern with branch-specific and tool-specific affordances
  • The readiness-label workflow that scopes an issue for agent or human implementation
  • The pattern you can copy into your own repository: skills directory, specs directory, root engineering guide, automated reviewer
Prerequisites
  • Familiarity with how AI coding agents discover and load context (system prompts, skills, slash commands)
  • Comfort reading YAML frontmatter and Markdown
  • No prior knowledge of Warp's internals required
1 / 6

The .agents/skills Directory

.agents/skills/spec-driven-implementation/SKILL.md:1

Every skill is a directory under .agents/skills/ containing a SKILL.md whose YAML frontmatter is what an agent harness reads first.

An agent loaded into a fresh repository has no context. It does not know what tooling exists, where tests live, what the team's review expectations are. .agents/skills/ answers that with a small directory of self-describing units. At the pinned commit there are twenty: add-feature-flag, add-telemetry, create-pr, fix-errors, implement-specs, resolve-merge-conflicts, review-pr, rust-unit-tests, spec-driven-implementation, write-product-spec, write-tech-spec, and others.

A harness like Claude Code reads the YAML frontmatter at load time. The name field is the skill's kebab-case identifier; the description is what gets matched against user intent. The body is loaded only when the skill is selected, so you can write thousands of words of guidance without bloating the system prompt. .claude/skills is a symlink to this same directory, so Claude Code reads exactly what every other harness reads.

Key takeaway

.agents/skills/ holds twenty SKILL.md files with structured frontmatter that any compatible harness can read. The symlink at .claude/skills proves the format is portable.

---
name: spec-driven-implementation
description: Drive a spec-first workflow for substantial features by writing PRODUCT.md before implementation, writing TECH.md when warranted, and keeping both specs updated as implementation evolves. Use when starting a significant feature, planning agent-driven implementation, or when the user wants product and tech specs checked into source control.
---

# spec-driven-implementation

Drive a spec-first workflow for substantial features in Warp.

## Overview

Use this skill for significant features where a written spec will improve implementation quality, reduce ambiguity, or make review easier. Be pragmatic: not every change needs specs.

Specs should usually live in:

- `specs/<linear-ticket-number>/PRODUCT.md`
- `specs/<linear-ticket-number>/TECH.md`
2 / 6

What a SKILL.md Actually Contains

.agents/skills/rust-unit-tests/SKILL.md:1

A representative SKILL.md is short, opinionated about scope and file layout, and ships ready-to-paste code patterns.

The shape is the message. Scope says what this skill is and is not for: crate-level unit tests, narrow per-case behavior, no integration territory. Where unit tests live answers a recurring question (separate _tests.rs file? same file? tests/ directory?) with one rule and a copy-pasteable snippet that registers the module.

A new agent picking up this skill gets the answer to the question "how do I add a unit test in this codebase" in under a minute. The rest of the file (not shown) covers App::test harness usage for view/model tests, async patterns with #[tokio::test], virtual filesystem helpers, feature flag overrides, and the exact cargo nextest run commands to run a single test or the full workspace. Every section is rule plus example, with no preamble.

Key takeaway

A good SKILL.md is short, opinionated, and full of paste-ready snippets, structured as rule plus example with no preamble. The agent reads it once and writes correct tests.

---
name: rust-unit-tests
description: Write, improve, and run Rust unit tests in the warp Rust codebase.
---

# Rust Unit Tests in warp

## Scope
- This skill focuses on crate-level unit tests.
- Favor incremental, well-scoped tests that exercise a single function or behavior per case.

## Where unit tests live
- Put unit tests in separate files named `${filename}_tests.rs` or `mod_test.rs`.
- Include the test module at the end of the corresponding source file:

```rust
#[cfg(test)]
#[path = "filename_tests.rs"] // or "mod_test.rs"
mod tests;
```
3 / 6

Specs Anchor Issues to Code Lines

specs/GH408/tech.md:7

A tech spec lists relevant files with line ranges so an agent has the diff frame before writing code.

An issue says "/open-file ~/foo.txt does not expand the tilde". A code PR fixes it. The work in between (deciding where the fix goes, finding the existing pattern to copy, identifying the test that already covers the surface area) is what the spec captures. specs/GH408/tech.md hands an agent four file references with line ranges before any code is written.

Notice the structure. The four references cover the code that needs to change (slash_commands/mod.rs:445-450), the existing pattern to follow (data_source.rs:196), a helper called along the same path, and the existing test to extend. An implementer who reads the spec already knows the diff shape: one tilde-expansion line added in slash_commands/mod.rs next to the existing unescape call, plus a test case in input_test.rs mirroring the existing one. The spec PR is the design discussion; the code PR is mechanical.

Key takeaway

Line-numbered file references in the tech spec collapse the discovery phase. The agent does not have to grep; it has the diff frame before writing.

The `/open-file` slash command handler does not expand `~` before resolving the file path. The argument is unescaped and then joined directly with the current working directory, so `~/foo.txt` becomes `/cwd/~/foo.txt`. The Cmd-O open file palette already handles this correctly by calling `shellexpand::tilde()`.

## Relevant code

- `app/src/terminal/input/slash_commands/mod.rs (445-450)` — The `/open-file` (`commands::EDIT`) handler that parses the path argument and resolves it. This is the code that needs to change.
- `app/src/search/command_palette/files/data_source.rs:196` — The Cmd-O palette's tilde expansion: `shellexpand::tilde(&query_file_content).into_owned()`. This is the pattern to follow.
- `crates/warp_util/src/path.rs (149-181)` — `CleanPathResult::with_line_and_column_number()`, which strips line/column suffixes from the path string. Called before path resolution.
- `app/src/terminal/input_test.rs (2553-2596)` — Existing test `test_open_slash_command_clears_buffer_on_success` that exercises the `/open-file` handler with a real file.

## Current state

The handler in `slash_commands/mod.rs` does this sequence:

1. Parses line/column suffix with `CleanPathResult::with_line_and_column_number(args.trim())`
4 / 6

Editor Affordances in .warp and .claude

.warp/skills/integration-test-video/SKILL.md:1

.warp/ ships skills that are branch-specific or local-environment-specific, separate from the cross-tool skills under .agents/.

Three directories at the root carry agent context, each playing a different role. .agents/skills/ is the cross-tool, branch-stable surface that any harness reads; .claude/skills symlinks to the same directory so Claude Code auto-discovers without duplication; .warp/ holds skills that should not be exposed to every harness or every branch.

The phrase "on this branch" is the giveaway. Branch-specific skills describe pipelines that exist only in a feature branch or a developer's local checkout. Putting them under .warp/skills/ instead of .agents/skills/ keeps the canonical skill set stable while still letting Warp's own tooling surface in-progress workflows. .mcp.json at the root completes the picture: it wires up the GitHub MCP server with a one-line npx -y @modelcontextprotocol/server-github, so any harness that supports MCP gets repo-aware tools without per-developer setup.

Key takeaway

.agents/ is cross-tool and stable; .warp/ is branch-specific or in-progress; .claude/ symlinks; .mcp.json is shared MCP wiring. Each directory has one job.

---
name: integration-test-video
description: Run Warp integration tests with screenshot and video capture, including event overlay annotations for mouse and keyboard input. Use this whenever the user wants to record an integration test, collect screenshots from a test, review generated recording artifacts, or author a test that captures video for debugging or demos.
---

# Integration Test Video Recording

Use this skill when working with Warp's integration test recording pipeline on this branch.

The relevant implementation lives in:
- `integration/src/bin/integration.rs`
- `integration/src/test/video_recording.rs`
- `integration/tests/integration/ui_tests.rs`
- `ui/src/integration/driver.rs`
- `ui/src/integration/step.rs`
- `ui/src/integration/video_recorder.rs`
- `ui/src/integration/artifacts.rs`
- `ui/src/integration/overlay.rs`
5 / 6

How Tasks Get Scoped for Agents

CONTRIBUTING.md:23

Readiness labels (ready-to-spec, ready-to-implement, needs-mocks) gate when an agent or contributor can act on an issue.

An agent that opens PRs against random issues produces noise. Warp's answer is a three-label state machine on every issue: ready-to-spec means the problem is understood and the next artifact is a spec PR (not code), ready-to-implement means the design is settled and code PRs are welcome, and needs-mocks means design work is still pending and nobody should write code yet.

The labels turn issue triage into a routing function. Bug reports go through Oz's automated triage and get ready-to-implement implicitly. Feature requests get ready-to-spec first; only after the spec is approved does implementation start. An agent reading the label knows whether to pick up the issue, propose a spec, or wait. The flow is: file issue, get labeled, write spec or code, open PR, Oz reviews, then a Warp engineer reviews.

Key takeaway

Three labels (ready-to-spec, ready-to-implement, needs-mocks) tell agents and humans what action the issue is ready for, and an unlabeled issue means no work yet.

  - Bug fixes skip both steps; they are implicitly `ready-to-implement` once triaged.
- **Review is largely automated.** When you open a PR, Oz is auto-assigned and produces an initial review. Once Oz approves, it automatically requests a follow-up review from a Warp team subject-matter expert — you do not need to assign human reviewers yourself.

### Readiness labels

The Warp team applies one of the following labels when an issue is ready for contribution:

- **`ready-to-spec`**The problem is understood but the design is open. Open a spec PR with a *product spec* (`product.md`) and a *tech spec* (`tech.md`) under [`specs/`](specs/) — see [Opening a Spec PR](#opening-a-spec-pr) for what goes in each. This label is **reserved for feature requests**.
- **`ready-to-implement`**The design is settled. Open a code PR. **All triaged bug reports are implicitly `ready-to-implement`** once accepted — you don't need to wait for an explicit label on a confirmed bug.
- **`needs-mocks`**Design mocks are required before implementation can begin. Wait for the Warp team to land them.

Anyone can pick up a ready issue — readiness labels are not assignments, and the best implementation wins through normal review. If an issue has been sitting un-triaged or you'd like readiness re-evaluated, mention **@oss-maintainers** in a comment to flag it for the team.
6 / 6

The Frontmatter Contract You Can Copy

.agents/skills/update-skill/SKILL.md:32

The meta-skill update-skill defines the frontmatter contract: kebab-case name, description that begins with an action verb and includes when to use the skill.

The pattern that makes this work in your own repository is small enough to copy directly. Pick a directory (.agents/skills/ is the emerging convention). Inside it, put one subdirectory per skill, each containing a SKILL.md with two-field YAML frontmatter: name in kebab-case, description starting with an action verb and stating both what and when.

The description rule is strict because harnesses match user intent against descriptions to decide which skills to load. "Helps with feature flags" loses to "Adds a new feature flag to gate code changes. Use when adding a feature behind a flag" every time. Write descriptions for retrieval, not for humans. Then add a specs/ directory pointed at by your contribution guide, and a WARP.md or AGENTS.md at the root for commands and conventions. The whole pattern is four files plus a directory; the rest is consistency.

Key takeaway

SKILL.md frontmatter is two fields: a kebab-case name and a description that starts with an action verb and answers what and when. Copy this contract; the rest follows.

## Requirements

### Frontmatter (Required)

Every SKILL.md must start with YAML frontmatter containing:

- **name**: Kebab-case identifier (lowercase letters, numbers, hyphens only)
  - Example: `add-feature-flag`, `rust-unit-tests`, `update-skill`
- **description**: Specific description of what the skill does and when to use it
  - Must be non-empty
  - Should include key terms for skill discovery
  - Begin with an action verb to clearly state what the skill accomplishes (e.g., "Adds feature flags..." instead of "Helps with features..."), and immediately follow with a specific use case or context (e.g., "Use when working with feature flags")
  - Write in third person (e.g., "Adds feature flags..." not "I can help you add...")

### Writing Effective Descriptions

The description field is critical for skill discovery. Include both **what** the skill does and **when** to use it. Some good examples:
Your codebase next

Create code tours for your project

Intraview lets AI create interactive walkthroughs of any codebase. Install the free VS Code extension and generate your first tour in minutes.

Install Intraview Free