New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Warp Telemetry Events

by warpdotdev in warpdotdev/warp

Adds telemetry events to the Warp codebase through its trait-based system, after agreeing with you what to track and why.

AGPL-3.0Auto-check passedDevelopment

Install Warp Telemetry Events

skills CLI
$ npx skills add warpdotdev/warp --skill add-telemetry -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install warpdotdev/warp add-telemetry --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/warpdotdev/warp.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/add-telemetry .claude/skills/add-telemetry && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
add-telemetry
GitHub stars
65k
Used in
1 other repo
Token cost
~1.3k tokens
SKILL.md length
295 words
Files
1
Skills in repo
46
Repo updated
First seen
Licence
AGPL-3.0

At a glance

Adds telemetry events to the Warp codebase through its trait-based system, after agreeing with you what to track and why.

  • Works in 7 steps: Identify or create a telemetry module → Define the telemetry event enum → Implement the TelemetryEvent trait → …
  • Instrumenting a new Warp feature with usage events
  • SKILL.md covers Overview, Steps, Best Practices and Example Reference
  • Calls cargo

What it does

Warp keeps telemetry in feature-specific enums that implement a `TelemetryEvent` trait instead of one large enum. Before writing code, the skill has the agent work out with you which events to track, what data each carries and what the data is for. The steps are to find or create a telemetry module, define the event enum, implement `TelemetryEvent` and `TelemetryEventDesc` for the discriminants, register the event and send it from code.

`EnablementState` controls when an event is sent: always, only behind a feature flag, or only in specific build channels. Events are sent with `send_telemetry_from_ctx!` from views and models, or `send_telemetry_from_app_ctx!` when only an app context is available. To check the result locally, run Warp with the `log_named_telemetry_events` feature flag so events are logged to the console.

When your agent uses it

  • Instrumenting a new Warp feature with usage events
  • Adding an event to measure a product metric
  • Adding a telemetry event while debugging an issue

Example prompts

  • “Add a telemetry event that fires when the user opens the command palette, behind a feature flag.”
  • “Let's decide which events to track for the new notebook feature, then add them.”
  • “Run Warp with named telemetry logging so I can check that the new event fires.”

Requirements

  • The Warp Rust codebase

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Identify or create a telemetry module
  2. Define the telemetry event enum
  3. Implement the TelemetryEvent trait
  4. Implement TelemetryEventDesc for the discriminants
  5. Register the telemetry event
  6. Send telemetry events from your code
  7. Test locally

What it can do on your machine

Read from SKILL.md and the folder at commit 325d4d4. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • cargo

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Warp Telemetry Events loads about 1.3k tokens when it runs. Until then it costs about 45 tokens; SKILL.md has 295 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~45
When it runs · the whole SKILL.md, loaded when a task matches
~1.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from warpdotdev/warp at commit 325d4d4, republished under its AGPL-3.0 licence (© warpdotdev). 295 words, ~1,300 tokens.

Download SKILL.mdSave it as .claude/skills/add-telemetry/SKILL.md (or your agent's skills folder).
name
add-telemetry
description
Add telemetry events to track user behavior or system events in the Warp codebase. Use when instrumenting new features, debugging issues, or measuring product metrics.

add-telemetry

Overview

Warp uses a trait-based telemetry system where feature-specific enums implement the TelemetryEvent trait. This approach keeps telemetry events organized by domain rather than in one giant enum.

Important: Before implementing telemetry, collaborate with the user to:

  • Define what events should be tracked and when
  • Determine what data should be included in each event
  • Clarify the purpose and expected usage of the telemetry

Adding telemetry code is straightforward, but designing meaningful instrumentation requires careful thought.

Steps

1. Identify or create a telemetry module

Find an existing feature-specific telemetry file (e.g., app/src/antivirus/telemetry.rs) or create a new one for your feature area.

2. Define the telemetry event enum

Add a new variant to an enum that implements TelemetryEvent, or create a new enum:

rust
use serde_json::{json, Value};
use strum_macros::{EnumDiscriminants, EnumIter};
use warp_core::telemetry::{EnablementState, TelemetryEvent, TelemetryEventDesc};

#[derive(Debug, EnumDiscriminants)]
#[strum_discriminants(derive(EnumIter))]
pub enum YourFeatureTelemetryEvent {
    ActionStarted {
        duration_ms: u64,
    },
    ActionCompleted {
        success: bool,
        error: Option<String>,
    },
}
3. Implement the TelemetryEvent trait

EnablementState allows you to control when events are sent:

  • EnablementState::Always - Always send the event
  • EnablementState::Flag(FeatureFlag::YourFeature) - Only send when the feature flag is enabled
  • EnablementState::Channel(Channel::Dev) - Only send in specific build channels
rust
impl TelemetryEvent for YourFeatureTelemetryEvent {
    fn name(&self) -> &'static str {
        YourFeatureTelemetryEventDiscriminants::from(self).name()
    }

    fn payload(&self) -> Option<Value> {
        match self {
            Self::ActionStarted { duration_ms } => Some(json!({
                "duration_ms": duration_ms,
            })),
            Self::ActionCompleted { success, error } => Some(json!({
                "success": success,
                "error": error,
            })),
        }
    }

    fn description(&self) -> &'static str {
        YourFeatureTelemetryEventDiscriminants::from(self).description()
    }

    fn enablement_state(&self) -> EnablementState {
        YourFeatureTelemetryEventDiscriminants::from(self).enablement_state()
    }

    fn contains_ugc(&self) -> bool {
        match self {
            Self::ActionStarted { .. } => false,
            Self::ActionCompleted { .. } => false,
        }
    }

    fn event_descs() -> impl Iterator<Item = Box<dyn TelemetryEventDesc>> {
        warp_core::telemetry::enum_events::<Self>()
    }
}
4. Implement TelemetryEventDesc for the discriminants
rust
impl TelemetryEventDesc for YourFeatureTelemetryEventDiscriminants {
    fn name(&self) -> &'static str {
        match self {
            Self::ActionStarted => "YourFeature.Action.Started",
            Self::ActionCompleted => "YourFeature.Action.Completed",
        }
    }

    fn description(&self) -> &'static str {
        match self {
            Self::ActionStarted => "User started the action",
            Self::ActionCompleted => "User completed the action",
        }
    }

    fn enablement_state(&self) -> EnablementState {
        match self {
            Self::ActionStarted | Self::ActionCompleted => EnablementState::Always,
            // Or gate behind a feature flag:
            // EnablementState::Flag(FeatureFlag::YourFeature)
        }
    }
}
5. Register the telemetry event

At the end of your telemetry module, register the event:

rust
warp_core::register_telemetry_event!(YourFeatureTelemetryEvent);
6. Send telemetry events from your code

Use send_telemetry_from_ctx! in views or models with a ViewContext or ModelContext:

rust
use warp_core::send_telemetry_from_ctx;

// In a view update or model method
send_telemetry_from_ctx!(
    YourFeatureTelemetryEvent::ActionStarted {
        duration_ms: 150,
    },
    ctx
);

For code with only AppContext, use send_telemetry_from_app_ctx! instead.

7. Test locally

Run Warp with the log_named_telemetry_events feature flag to see telemetry events logged to the console:

bash
cargo run --features log_named_telemetry_events

Best Practices

  • Keep telemetry enums feature-specific rather than adding to a global enum
  • Set contains_ugc() to true if the payload includes user-generated content
  • Use descriptive event names following the pattern Feature.Action.Result
  • Include only necessary data in payloads to minimize bandwidth and storage
  • Consider privacy implications when deciding what data to include
  • Avoid exhaustive matching with wildcards; handle all variants explicitly

Example Reference

See app/src/antivirus/telemetry.rs for a complete example of a feature-specific telemetry implementation.

© warpdotdev, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/add-telemetry of warpdotdev/warp.

Open the folder on GitHubat commit 325d4d4

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in warpdotdev/warp, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Warp Telemetry Events next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Warp Telemetry Events compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Warp Telemetry Events this skillwarpdotdev/warp65k1 repos~1.3kAutomated safety check: PassAGPL-3.0
Rust SkillsJMBeresford/retrom2.1k1 repos~9.5kAutomated safety check: PassMIT
Debugging Techniquesancoleman/ai-design-components526—~3.3kAutomated safety check: PassMIT
Rust Debuggingmohitmishra786/low-level-dev-skills253—~1.6kAutomated safety check: PassMIT
Ebpf Rustmohitmishra786/low-level-dev-skills253—~1.7kAutomated safety check: PassMIT
Add React Analyticsgotempsh/temps826—~2.7kAutomated safety check: PassApache-2.0

Similar skills

  • Rust Skills

    JMBeresford/retrom

    Comprehensive Rust coding guidelines with 265 rules across 26 categories.

    2.1k GitHub starsUsed in 1 repo~9.5k tokens
    DevelopmentAuto-check passed

  • Debugging Techniques

    ancoleman/ai-design-components

    Debugging workflows for Python (pdb, debugpy), Go (delve), Rust (lldb), and Node.js, including container debugging (kubectl debug, ephemeral containers) and production-safe debugging techniques with…

    526 GitHub stars~3.3k tokensUpdated 10 mo ago
    DevelopmentAuto-check passed

  • Rust Debugging

    mohitmishra786/low-level-dev-skills

    Rust debugging skill for systems programming. An agent skill from mohitmishra786/low-level-dev-skills.

    253 GitHub stars~1.6k tokensUpdated 3 mo ago
    DevelopmentAuto-check passed

  • Ebpf Rust

    mohitmishra786/low-level-dev-skills

    Rust eBPF skill using the Aya framework. An agent skill from mohitmishra786/low-level-dev-skills.

    253 GitHub stars~1.7k tokensUpdated 3 mo ago
    DevelopmentAuto-check passed

  • Add React Analytics

    gotempsh/temps

    Add Temps analytics to React applications with comprehensive tracking capabilities including page views, custom events, scroll tracking, engagement monitoring, session recording, and Web Vitals…

    826 GitHub stars~2.7k tokensUpdated today
    DevOps & CloudAuto-check passed

  • Logfire Instrumentation

    basicmachines-co/basic-memory

    Adds Pydantic Logfire tracing, logging and metrics to Python, JavaScript or TypeScript and Rust projects, with the correct setup order and library extras.

    4.1k GitHub stars~2.3k tokensUpdated today
    DevOps & CloudAuto-check passed

More from warpdotdev/warp

All 46 skills in this repo

  • Figma Design System Builder

    warpdotdev/warp

    Builds or updates a design system in Figma from a codebase in ordered phases: discovery, variables and tokens, components, theming and documentation, with checkpoints.

    65k GitHub starsUsed in 2 repos~4.4k tokens
    Auto-check passed

  • Figma use_figma Plugin API Rules

    warpdotdev/warp

    Required groundwork before any use_figma call: the rules and reference files for running JavaScript in a Figma file through the Plugin API without common failures.

    65k GitHub starsUsed in 4 repos~4.4k tokens
    Auto-check passed

  • Warp Factory Files

    warpdotdev/warp

    Authors and edits file-based Warp software factory definitions rooted at factory.yaml, covering agents, automations, scorers and webhooks, and validates them before a pull request.

    65k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed

  • Figma Design to Code

    warpdotdev/warp

    Turns a Figma frame or component into production code that matches the design, using the Figma MCP server and the project's own design system.

    65k GitHub starsUsed in 4 repos~2.9k tokens
    Auto-check passed

  • Warp GUI to Agent CLI Migration

    warpdotdev/warp

    Migrates the compatible subset of settings and global file-based MCP servers from the Warp desktop app into Warp Agent CLI without exposing credentials or state.

    65k GitHub starsUsed in 1 repo~2.1k tokens
    Auto-check passed

  • Figma Design System Rules Generator

    warpdotdev/warp

    Creates project-specific design system rules from your codebase so coding agents implement Figma designs with your components, naming and tokens.

    65k GitHub starsUsed in 3 repos~4.6k tokens
    Auto-check passed

Works with

Categories

Questions about Warp Telemetry Events

What does Warp Telemetry Events do?

Adds telemetry events to the Warp codebase through its trait-based system, after agreeing with you what to track and why. Warp keeps telemetry in feature-specific enums that implement a `TelemetryEvent` trait instead of one large enum. Before writing code, the skill has the agent work out with you which events to track, what data each carries and what the data is for.

When should I use Warp Telemetry Events?

Warp Telemetry Events fits situations like: instrumenting a new Warp feature with usage events; adding an event to measure a product metric; adding a telemetry event while debugging an issue.

How do I install Warp Telemetry Events in Claude Code?

Run `npx skills add warpdotdev/warp --skill add-telemetry -a claude-code`. Or copy the skill folder (.agents/skills/add-telemetry in warpdotdev/warp) into .claude/skills/add-telemetry in your project. Claude Code loads it when a task matches its description.

How do I install Warp Telemetry Events in Codex?

Run `npx skills add warpdotdev/warp --skill add-telemetry -a codex`. Or copy the skill folder (.agents/skills/add-telemetry in warpdotdev/warp) into .agents/skills/add-telemetry in your project. Codex loads it when a task matches its description.

Can I use Warp Telemetry Events in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add warpdotdev/warp --skill add-telemetry -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/add-telemetry, .gemini/skills/add-telemetry, .github/skills/add-telemetry and .opencode/skills/add-telemetry in your project.

What does Warp Telemetry Events need to run?

Going by SKILL.md and its folder, Warp Telemetry Events needs the command-line tools its instructions call (cargo). Our summary lists: The Warp Rust codebase.

Does Warp Telemetry Events access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Warp Telemetry Events safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Warp Telemetry Events use?

Warp Telemetry Events is published under the AGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Warp Telemetry Events use?

About 1.3k tokens (SKILL.md is roughly 5.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Warp Telemetry Events?

Skills that share tags, products or a category with Warp Telemetry Events: Rust Skills (JMBeresford/retrom, 2.1k stars), Debugging Techniques (ancoleman/ai-design-components, 526 stars), Rust Debugging (mohitmishra786/low-level-dev-skills, 253 stars) and Ebpf Rust (mohitmishra786/low-level-dev-skills, 253 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Warp Telemetry Events?

warpdotdev (a GitHub organization) maintains it in warpdotdev/warp, which has 65,395 GitHub stars. The repository holds 46 skills in this directory. The repository was last updated on October 8, 2026.

Source: warpdotdev/warp on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.