chore(skills): rename skill directories with codspeed prefix

Rename optimize -> codspeed-optimize and setup-harness ->
codspeed-setup-harness for clearer namespacing as plugin skills.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: art049

skills/optimize/SKILL.md skills/codspeed-optimize/SKILL.mdskills/optimize/SKILL.md renamed to skills/codspeed-optimize/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: optimize
+name: codspeed-optimize
 description: "Autonomously optimize code for performance using CodSpeed benchmarks, flamegraph analysis, and iterative improvement. Use this skill whenever the user wants to make code faster, reduce CPU usage, optimize memory, improve throughput, find performance bottlenecks, or asks to 'optimize', 'speed up', 'make faster', 'reduce latency', 'improve performance', or points at a CodSpeed benchmark result wanting improvements. Also trigger when the user mentions a slow function, a regression, or wants to understand where time is spent in their code."
 ---
 
@@ -87,6 +87,7 @@ Use the CodSpeed MCP tools to understand where time is spent:
 Apply optimizations one at a time. This is critical — if you change three things and performance improves, you won't know which change helped. If it regresses, you won't know which one hurt.
 
 **Important constraints:**
+
 - Only change code you've read and understood
 - Preserve correctness — run existing tests after each change
 - Keep changes minimal and focused
@@ -148,11 +149,13 @@ codspeed exec -m walltime -- <command>
 Then compare the walltime run against a walltime baseline using `compare_runs`.
 
 **Patterns that often show up in simulation but NOT walltime:**
+
 - Iterator adapter overhead (e.g., `.take(n)` to `[..n]`) — branch prediction hides it
 - Bounds check elimination — hardware speculates past them
 - Trivial arithmetic simplifications — hidden by out-of-order execution
 
 **Patterns that reliably help in both modes:**
+
 - Avoiding type conversions in hot loops (float/integer round-trips)
 - Eliminating libm calls (roundf, sinf — these are software routines)
 - Skipping redundant memory initialization
@@ -165,6 +168,7 @@ If a simulation improvement doesn't show up in walltime, strongly consider rever
 If the user wants more optimization, go back to Step 2 with fresh flamegraphs from your latest run. The profile will have shifted now that you've addressed the top bottleneck, revealing new targets.
 
 Keep iterating until:
+
 - The user says they're satisfied
 - The flamegraph shows no clear bottleneck (time is spread evenly)
 - Remaining optimizations would require architectural changes the user hasn't approved
@@ -173,28 +177,34 @@ Keep iterating until:
 ## Language-specific notes
 
 ### Rust
+
 - Use `cargo codspeed build -m <mode>` to build, `cargo codspeed run` to run
 - `--bench <name>` selects specific benchmark suites (matching `[[bench]]` targets in Cargo.toml)
 - Positional filter after `cargo codspeed run` matches benchmark names (e.g., `cargo codspeed run cat.jpg`)
 - Frameworks: criterion, divan, bencher (all work with cargo-codspeed)
 
 ### Python
+
 - Uses pytest-codspeed: `codspeed run -m simulation -- pytest --codspeed`
 - Framework: pytest-benchmark compatible
 
 ### Node.js
+
 - Frameworks: vitest (`@codspeed/vitest-plugin`), tinybench v5 (`@codspeed/tinybench-plugin`), benchmark.js (`@codspeed/benchmark.js-plugin`)
 - Run via: `codspeed run -m simulation -- npx vitest bench` (or equivalent)
 
 ### Go
+
 - Built-in: `codspeed run -m simulation -- go test -bench .`
 - No special packages needed — CodSpeed instruments `go test -bench` directly
 
 ### C/C++
+
 - Uses Google Benchmark with valgrind-codspeed
 - Build with CMake, run benchmarks via `codspeed run`
 
 ### Any language (exec harness)
+
 - Use `codspeed exec -m <mode> -- <command>` for any executable
 - Or define benchmarks in `codspeed.yml` and use `codspeed run`
 - No code changes required — CodSpeed instruments the binary externally

skills/setup-harness/SKILL.md skills/codspeed-setup-harness/SKILL.mdskills/setup-harness/SKILL.md renamed to skills/codspeed-setup-harness/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: setup-harness
+name: codspeed-setup-harness
 description: "Set up performance benchmarks and CodSpeed harness for a project. Use this skill whenever the user wants to create benchmarks, add performance tests, set up CodSpeed, configure codspeed.yml, integrate a benchmarking framework (criterion, divan, pytest-benchmark, vitest bench, go test -bench, google benchmark), or when the user says 'add benchmarks', 'set up perf tests', 'create a benchmark', 'benchmark this', or wants to measure performance of their code for the first time. Also trigger when the optimize skill needs benchmarks that don't exist yet."
 ---
 
@@ -27,13 +27,13 @@ Based on the language and what the user wants to benchmark, pick the right harne
 
 These integrate deeply with CodSpeed and provide per-benchmark flamegraphs, fine-grained comparison, and simulation mode support.
 
-| Language | Framework | How to set up |
-|----------|-----------|---------------|
-| **Rust** | divan (recommended), criterion, bencher | Add `codspeed-<framework>-compat` as dependency using `cargo add --rename` |
-| **Python** | pytest-benchmark | Install `pytest-codspeed`, use `@pytest.benchmark` or `benchmark` fixture |
-| **Node.js** | vitest (recommended), tinybench v5, benchmark.js | Install `@codspeed/<framework>-plugin`, configure in vitest/test config |
-| **Go** | go test -bench | No packages needed — CodSpeed instruments `go test -bench` directly |
-| **C/C++** | Google Benchmark | Build with CMake, CodSpeed instruments via valgrind-codspeed |
+| Language    | Framework                                        | How to set up                                                              |
+| ----------- | ------------------------------------------------ | -------------------------------------------------------------------------- |
+| **Rust**    | divan (recommended), criterion, bencher          | Add `codspeed-<framework>-compat` as dependency using `cargo add --rename` |
+| **Python**  | pytest-benchmark                                 | Install `pytest-codspeed`, use `@pytest.benchmark` or `benchmark` fixture  |
+| **Node.js** | vitest (recommended), tinybench v5, benchmark.js | Install `@codspeed/<framework>-plugin`, configure in vitest/test config    |
+| **Go**      | go test -bench                                   | No packages needed — CodSpeed instruments `go test -bench` directly        |
+| **C/C++**   | Google Benchmark                                 | Build with CMake, CodSpeed instruments via valgrind-codspeed               |
 
 ### Exec harness (universal)
 
@@ -43,6 +43,7 @@ For any language or when you want to benchmark a whole program (not individual f
 - Or create a `codspeed.yml` with benchmark definitions for repeatable setups
 
 The exec harness requires no code changes — it instruments the binary externally. This is ideal for:
+
 - Languages without a dedicated CodSpeed integration
 - End-to-end benchmarks (full program execution)
 - Quick setup when you just want to track a command's performance
@@ -58,12 +59,14 @@ The exec harness requires no code changes — it instruments the binary external
 ### Rust with divan (recommended)
 
 1. Add the dependency:
+
 ```bash
 cargo add divan
 cargo add codspeed-divan-compat --rename divan --dev
 ```
 
 2. Create a benchmark file in `benches/`:
+
 ```rust
 // benches/my_bench.rs
 use divan;
@@ -81,13 +84,15 @@ fn bench_my_function() {
 ```
 
 3. Add to `Cargo.toml`:
+
 ```toml
 [[bench]]
 name = "my_bench"
 harness = false
 ```
 
 4. Build and run:
+
 ```bash
 cargo codspeed build -m simulation --bench my_bench
 codspeed run -m simulation -- cargo codspeed run --bench my_bench
@@ -96,12 +101,14 @@ codspeed run -m simulation -- cargo codspeed run --bench my_bench
 ### Rust with criterion
 
 1. Add dependencies:
+
 ```bash
 cargo add criterion --dev
 cargo add codspeed-criterion-compat --rename criterion --dev
 ```
 
 2. Create benchmark in `benches/`:
+
 ```rust
 use criterion::{criterion_group, criterion_main, Criterion};
 
@@ -120,13 +127,15 @@ criterion_main!(benches);
 ### Python with pytest-codspeed
 
 1. Install:
+
 ```bash
 pip install pytest-codspeed
 # or
 uv add --dev pytest-codspeed
 ```
 
 2. Create benchmark tests:
+
 ```python
 # tests/test_benchmarks.py
 import pytest
@@ -143,20 +152,23 @@ def test_with_setup(benchmark):
 ```
 
 3. Run:
+
 ```bash
 codspeed run -m simulation -- pytest --codspeed
 ```
 
 ### Node.js with vitest (recommended)
 
 1. Install:
+
 ```bash
 npm install -D @codspeed/vitest-plugin
 # or
 pnpm add -D @codspeed/vitest-plugin
 ```
 
 2. Configure vitest (`vitest.config.ts`):
+
 ```typescript
 import { defineConfig } from "vitest/config";
 import codspeed from "@codspeed/vitest-plugin";
@@ -167,6 +179,7 @@ export default defineConfig({
 ```
 
 3. Create benchmark file:
+
 ```typescript
 // bench/my.bench.ts
 import { bench, describe } from "vitest";
@@ -179,6 +192,7 @@ describe("my module", () => {
 ```
 
 4. Run:
+
 ```bash
 codspeed run -m simulation -- npx vitest bench
 ```
@@ -188,6 +202,7 @@ codspeed run -m simulation -- npx vitest bench
 No packages needed — CodSpeed instruments `go test -bench` directly.
 
 1. Create benchmark tests:
+
 ```go
 // my_test.go
 func BenchmarkMyFunction(b *testing.B) {
@@ -198,6 +213,7 @@ func BenchmarkMyFunction(b *testing.B) {
 ```
 
 2. Run (walltime is the default for Go):
+
 ```bash
 codspeed run -m walltime -- go test -bench . ./...
 ```
@@ -207,6 +223,7 @@ codspeed run -m walltime -- go test -bench . ./...
 1. Install Google Benchmark (via CMake FetchContent or system package)
 
 2. Create benchmark:
+
 ```cpp
 #include <benchmark/benchmark.h>
 
@@ -221,6 +238,7 @@ BENCHMARK_MAIN();
 ```
 
 3. Build and run with CodSpeed:
+
 ```bash
 cmake -B build && cmake --build build
 codspeed run -m simulation -- ./build/my_benchmark
@@ -231,6 +249,7 @@ codspeed run -m simulation -- ./build/my_benchmark
 For benchmarking whole programs without code changes:
 
 1. Create `codspeed.yml`:
+
 ```yaml
 $schema: https://raw.githubusercontent.com/CodSpeedHQ/codspeed/refs/heads/main/schemas/codspeed.schema.json
 
@@ -249,11 +268,13 @@ benchmarks:
 ```
 
 2. Run:
+
 ```bash
 codspeed run -m walltime
 ```
 
 Or for a one-off:
+
 ```bash
 codspeed exec -m walltime -- ./my_binary --input data.txt
 ```
@@ -279,6 +300,7 @@ Good benchmarks are representative, isolated, and stable. Here are guidelines:
 After setting up:
 
 1. **Run the benchmarks locally** to verify they work:
+
 ```bash
 # For language-specific harnesses
 cargo codspeed build -m simulation && codspeed run -m simulation -- cargo codspeed run