Intel Performance Skills

Three Intel skills for Linux perf: profiling, finding bottlenecks in code and perf output, and tuning Phoronix benchmarks

  • 353 ★ on the repository
  • Last commit
SkillOfficial

Extended access

Why this level

  • The skill runs perf, and hardware counters may need sudo or a lower perf_event_paranoid (it asks you first)
  • The phoronix-test-suite skill downloads, installs and rebuilds benchmarks on your machine
All reasons and checks

intel/intel-performance-skills

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/intel-performance-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 skill runs perf, and hardware counters may need sudo or a lower perf_event_paranoid (it asks you first)
  • The phoronix-test-suite skill downloads, installs and rebuilds benchmarks on your machine

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

What it does

Intel Performance Skills bundles three skills for analyzing and speeding up code on x86 Linux. The linux-perf skill runs profiling through perf in five flows: perf stat shows IPC and cache and branch miss rates, perf record with perf report finds the functions and lines that spend CPU, perf c2c looks for cache-line contention and false sharing. The fourth flow compares two profiles at different core counts, the fifth produces a final report: a table of top functions, annotated source and the patterns found. The performance-patterns skill holds a catalog of common problems with signals and fixes: serial accumulator, narrow SIMD, missing vzeroupper, missing restrict, Test-and-Set spinlock, false sharing, shared statistics counter. It works without a profile, from source alone, and guides how to write new vectorized code with CPU dispatch. The phoronix-test-suite skill installs, runs and rebuilds pts benchmarks with debug symbols when such a test is the profiling target.

Who it is for. C and C++ developers and performance engineers on x86 Linux who profile code with perf and want an agent to lead the process step by step.

Good fit when

  • A program runs slowly and the agent has to find where CPU time goes
  • A loop runs at an IPC of about 0.3 with few cache misses and the cause must be found
  • A server slows down as threads are added and false sharing is checked with perf c2c
  • A workload does not scale past 8 cores, and comparing two profiles will show the bottleneck
  • The pts/compress-zstd benchmark needs a profile and an optimization with before and after numbers

Not a fit when

  • The machine is not x86 Linux: the skills are written for x86 and the perf tool
  • There is no permission for counters: with perf_event_paranoid of 2 or higher hardware events need root
  • The code is not C or C++, for example Java or Python: the README patterns concern C, C++ and SIMD

Example request

Profile ./myapp --bench and tell me where the time goes

Limitations

The skills target x86 Linux and the perf tool. Hardware counters need root when perf_event_paranoid is 2 or higher: the skill lists running under sudo, lowering the parameter with a sudo tee command or skipping collection and waits for your answer. Annotations need debug symbols, so a binary is often rebuilt with the -g flag. The phoronix-test-suite skill downloads and rebuilds benchmarks from the Phoronix Test Suite. The pattern catalog covers the listed problems and does not promise to find every bottleneck.

How to disable. Delete the linux-perf, performance-patterns and phoronix-test-suite folders from the agent's skills directory (~/.claude/skills/, .agents/skills/ and similar). The README has no uninstall command for gh skill.

FAQ

How do I install the Intel skills in Claude Code?

With gh skill install intel/intel-performance-skills linux-perf and the same for the other two skills; GitHub CLI 2.90.0 or newer is needed. By hand the folders from skills/ are copied into ~/.claude/skills/ or the project's .claude/skills/.

Which problems does performance-patterns find?

Serial accumulator, narrow SIMD in a hot loop, missing vzeroupper and restrict, Test-and-Set spinlock, false sharing and a shared statistics counter. The catalog also has mutex to rwlock, fast CRC32C and SIMD sort.

Is root needed to collect a profile?

For hardware events with perf_event_paranoid of 2 or higher, yes. The skill lists three ways out: run under sudo, lower the parameter or skip collection, and waits for your choice.

Does the skill work without a profile?

Yes, performance-patterns also reviews a single source file. The README example checks a dot-product loop for performance problems without running it. It also guides how to write vectorized code correctly from the start.

What does perf c2c do in the skill?

Flow C looks for cache-line contention: false sharing and HITM events in multi-threaded code. The skill passes a found pattern to performance-patterns for the fix.

Discussion

No questions or reviews yet.

Skills

Over 140 skills for systems programming: compilers, debuggers, profilers, firmware, the Linux kernel and binary analysis.

SkillMinimal access279Repository stars

Embedded Skills

embeddedskills

Skills for embedded development: AI drives compilers, debuggers (J-Link and others) and buses (CAN) from code to hardware checks. README in Chinese and English

WorkflowBroad access787Repository stars
Official

Official Qt skills: C++ and QML review, QML and CMake best practices, Qt Quick tests, docs, profiler and Figma to QML, plus an MCP server with Qt docs

SkillExtended access523Repository stars

A skill for speeding up model training on Moore Threads MUSA GPUs: baseline, profiling, MFU and numerical correctness checks

SkillExtended access139Repository stars

Over 180 software engineering skills for bugs, tests, requirements, DevOps, security and formal verification, plus task packs

SkillBroad access260Repository stars

A skill that speeds up Xcode builds: benchmarks clean and incremental builds, finds bottlenecks and tunes project settings

SkillExtended access1.3KRepository stars

README in short

The page opens with sample prompts for the agent, then describes each of the three skills with triggers and a pattern table. Install through gh skill and by copying for GitHub Copilot, Claude Code, Codex, Gemini CLI and OpenCode follows, then the MIT license.

README badge

Original SKILL.md

---
name: linux-perf
description: >-
  Profile and fix Linux performance problems using `perf`. Workflows: (A) hardware counters -- IPC, cache-miss, branch mispredictions; (B) hotspot profiling -- which functions and source lines consume CPU, with SIMD and accumulator detection; (C) cache-line contention -- false sharing, HITM, `perf c2c`; (D) core-count scaling -- dual-profile comparison, bottleneck categorization; (E) structured hotspot report with annotated source and pattern observations. Resolution strategies: TTAS spinlock, SIMD upconversion, parallel accumulator, structured false-sharing fix, per-CPU stats. Trigger on: perf, profiling, profile, hotspot, hotspots, cache miss, IPC, false sharing, HITM, scaling, core count, thread scaling, bottleneck, slow code, CPU bound, why is this slow, where does time go, does not scale. When in doubt, invoke this skill -- better to use it unnecessarily than to miss a performance opportunity.
---

<!-- (C) 2026 Intel Corporation, MIT license -->


# Linux perf profiling skill

Guide the user through profiling with Linux `perf` — from setup and data collection through reporting and interpretation.

The skill is organized into five parts:
- **Part 1: Setup** — permissions and build flags (always check these first)
- **Part 2: Flows** — end-to-end workflows (A: quick stats, B: hotspot profiling, C: cache contention)
- **Part 3: Cross-skill integrations** and **Reference** — when to delegate, and quick lookup tables
- **Part 4: Building blocks** — focused data collection primitives that flows and other skills can call directly
- **Part 5: Resolution strategies** — common fix patterns that flows can reference by name

---

# Part 1: setup

## Check permissions (always do this first)

```bash
cat /proc/sys/kernel/perf_event_paranoid
```

- **≤ 1**: no `sudo` needed for most data collection
- **2 or higher**: hardware events (cycles, cache-misses, etc.) require root

To lower the limit (ask the user first):
```bash
echo 0 | sudo tee /proc/sys/kernel/perf_event_paranoid
```

**Sudo protocol**: if `sudo` is needed, present these options and wait for the user's answer before proceeding:
1. Run with `sudo`
2. Lower paranoia level with the command above
3. Skip perf collection

## Ensure debug symbols

**Always compile with `-g`** alongside existing optimization flags (e.g. `-O2 -g`). This adds DWARF debug info so `perf report` and `perf annotate` show function names and source lines — it does not weaken optimization.

If given a pre-built binary without `-g`, offer to recompile. If you cannot, use **Building block: resolve address to source** (Part 4) for address correlation.

```bash

Report a problem

Foxx AIIntel Performance 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.