Claude Skills by Ugbot

Coordinate multiple AI agents working on the same machine and codebases via the devtools-mcp local collaboration layer: file-touch reporting hooks, advisory file claims (leases), conflict checks, and the /collab dashboard page, all linked to tracker tasks. Use when running more than one agent at once (Claude Code, Cursor, Codex), when an edit warns that another agent is on the file, when asked "who is working on what", or to claim files before a big refactor. A multi-user team collab server i...

Sketch types, signatures, and module structure before code, then stay in the loop while implementation fills in. Use for /architect, 'architect this', 'design this', or non-trivial work where jumping to code would lock in the wrong shape.

Drive build systems and package managers, Maven, Gradle, npm, pnpm, yarn, and Cargo, through the devtools-mcp backends without drowning in output. Use to build/test a project, inspect its dependency tree and SUBDEPENDENCIES (versions, depth, conflicts), synchronize/resolve/install deps, run a security audit, find outdated packages, or list runnable tasks/scripts. One verb vocabulary across every language; output is a bounded summary + a queryable Polars frame.

Debug native Windows programs and crash dumps via the devtools-mcp cdb backend (batch-mode CDB). Use when a Windows .exe crashes, you have a .dmp file, or you need all-thread stacks / a crash bucket without a GUI debugger. Covers !analyze -v triage, ~*k thread stacks, register/locals inspection, installing cdb, and symbol setup. Headless and scriptable, the Windows analog of the LLDB debug tools.

Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

How to drive the devtools-mcp server, the normalized interface over Valgrind, LLDB, DTrace, perf, Windows ETW (PerfView), the JVM (JFR/jstack/jmap/async- profiler), and the Windows debugger (CDB), plus flame graphs. Use whenever you need to profile or debug a native or JVM program through devtools-mcp: pick a suite/tool, run it, then drill into the resulting Polars frame instead of reading raw output. Explains the no-token-flood query workflow.

Use the devtools-mcp browser visualization terminal, a local web UI for every profiling/debugging run. Use when you want to SEE the data a human can explore: interactive (click-to-zoom) flame graphs, the queryable data table per run, raw logs, and the tracker as card boards (projects, status columns, task detail), across Linux/macOS/Windows. Covers starting/stopping the dashboard, what each view shows, and the CRDT sync API it serves for other replicas. The visual companion to devtools-mcp-us...

CPU-profile native Windows programs via the devtools-mcp ETW backend (PerfView). Use when you need to find CPU hotspots in a Windows .exe: Exc%/Inc% tables, call attribution, and flame graphs. Covers the symbol-resolution prerequisites (PDBs, _NT_SYMBOL_PATH), the elevation/exit-code-2 gotcha, and how to read the output. The deep-dive complement to bench-rdtsc-profile (which says WHICH function; this says WHY).

How to read and reason about flame graphs (and the devtools-mcp text flame-tree / Exc%-Inc% tables). Use when you've generated a flame graph or CPU profile and need to interpret it: find the real bottleneck, tell a wide plateau from a tall tower, distinguish exclusive (leaf) from inclusive (subtree) time, and avoid the classic misreadings. Applies to output from etw, jvm jfr/asprof, dtrace profile, perf, and cdb stacks.

Builds production-quality, accessible, responsive user-facing UIs. Use when building or modifying interfaces and pages, creating components, implementing layouts, meeting WCAG accessibility requirements, managing state, or when the output needs to look and feel production-quality rather than AI-generated.

Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

Use for \"interrogate\", \"adversarial review\", \"multi-model review\", \"challenge this\", \"stress test this code\", \"find blind spots\", or \"tear this apart\". Multiple LLM reviewers challenge changes from independent angles.

Profile Node.js and JavaScript via the devtools-mcp node backend: V8 CPU profiles (--cpu-prof) and sampling heap profiles (--heap-prof), turned into flame graphs and queryable hotspot tables. Use when a Node script/server is slow (CPU) or memory-hungry (allocations) and you want to see which functions are hot or allocating. Needs Node.js on PATH; nothing else.

CPU and allocation profile a running JVM via the devtools-mcp jvm backend: JFR (Java Flight Recorder, built into the JDK) or async-profiler. Use when a Java process is slow or allocating heavily and you need hot methods + a flame graph. Covers attaching by PID, choosing JFR vs async-profiler, and reading the method-level Exc%/Inc% output. For thread dumps and heap histograms see jvm-threads-heap.

Diagnose JVM thread state and memory via the devtools-mcp jvm backend: thread dumps (jstack / Thread.print) and heap histograms (jmap / GC.class_ histogram). Use when a Java process hangs, deadlocks, is stuck/blocked, or its heap is growing, to see thread states, lock contention, deadlocks, and the classes retaining the most bytes. For CPU/alloc sampling use jvm-profiling.

Create and evolve "live skills": SKILL.md files backed by CRDT documents (pycrdt) that agents edit in place and sync between machines, so a skill improved on one box updates everywhere. Use when asked to make a skill live/shared/self-updating, to record a newly-learned technique into a skill, to sync skills with another machine, or when a skill should accumulate team knowledge instead of being a static file.

Spawn Comment Sicko, fix accepted findings, and offer encodings for claimed constraints.

Instruments code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting. Use when shipping any feature that runs in production and you need evidence it works. Use when production issues are reported but you can't tell what happened from the available data.

Optimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.

Core PowerShell language idioms and the Windows PowerShell 5.1 vs PowerShell 7 split. Use whenever writing or fixing a PowerShell command/script and you hit "operator is not recognized", a ternary/?? that won't parse, unexpected text output, files that open as garbled UTF-16, or you need to know which edition a feature requires. Covers chaining, ternary, null-coalescing, here-strings, the object pipeline, comparison operators, and default encoding.

Environment variables, PATH, and package managers in PowerShell. Use when you need to read/set an env var, make an env change persist across sessions, edit PATH, or install/update CLI tools via winget, scoop, or choco. Covers the difference between session-only ($env:) and persistent ([Environment]::SetEnvironmentVariable) changes. 5.1 and 7+ behave the same here.

Error handling in PowerShell: terminating vs non-terminating errors, try/catch, -ErrorAction, $ErrorActionPreference, $LASTEXITCODE, and exit codes. Use when a try/catch isn't catching, when a cmdlet "fails" but the script keeps going, when -ErrorAction SilentlyContinue still makes the script report failure, when you need a script to exit non-zero on error, or when deciding how to make errors fatal. Covers both 5.1 and 7+.

Filesystem operations in PowerShell and the Unix-command equivalents (head/tail/which/touch/mkdir -p/rm -rf/ln -s/wc -l). Use when you need to list/find/copy/move/delete files, handle paths with spaces, create or remove directories safely, make symlinks, read first/last N lines, or translate a bash file command into PowerShell. Covers safety traps like Remove-Item prompts and New-Item -Force truncation. 5.1 and 7+.

Running work in the background or in parallel in PowerShell: Start-Job, ThreadJob, ForEach-Object -Parallel, Start-Process, and runspaces. Use when you need to run commands concurrently, launch a long-running process without blocking, fan out work over many items, wait on / collect background results, or speed up an I/O-bound loop. Notes which mechanisms are 7+ only vs available in 5.1.

Invoking native executables (git, npm, docker, .exe) from PowerShell correctly. Use when a native command's args get mangled, when paths with spaces fail, when redirecting a native command's stderr makes PowerShell report failure on exit 0 (NativeCommandError), when an exe's exit code isn't being detected, or when an argument starting with - / -- / @ is misparsed. Covers the call operator, --% stop-parsing, $LASTEXITCODE vs $?, and stdout/stderr capture.

Writing PowerShell that runs safely under automation / -NonInteractive (CI, agents, scheduled tasks, this harness) without hanging on a prompt. Use when a command might block waiting for input, when a destructive cmdlet pops a confirmation, when you need a command to fail fast instead of prompting, or when porting an interactive script to run headless. Lists the blocking cmdlets to avoid and their non-interactive replacements. 5.1 and 7+.

Writing robust PowerShell scripts and functions: param blocks, [CmdletBinding()], advanced functions, $PSScriptRoot, Set-StrictMode, comment-based help, modules, and Pester tests. Use when authoring a .ps1 script or reusable function, adding parameters/validation, making a script locate its own files, hardening against typos with strict mode, or setting up tests. Applies to 5.1 and 7+ with edition notes.

Working with text and structured data in PowerShell: JSON, CSV, regex, Select-String (grep), string manipulation, and here-strings. Use when you need to parse or emit JSON/CSV, grep file contents, extract with regex, build multi-line strings, or when ConvertFrom-Json gives you a PSCustomObject you expected to be a hashtable. Covers the -AsHashtable difference between 5.1 and 7+.

Profile and inspect Python programs via the devtools-mcp py backend: py-spy (sampling CPU flame graphs, attach to any running process), py-spy dump (thread stacks of a hung process), and cProfile (deterministic call stats). Use when Python code is slow, stuck, or you want a flame graph or per-function timing. cProfile is stdlib (works now); py-spy is `pip install py-spy`.

Reconstruct your recent working context from your own chat history, live state, and the shared record (user reports, prior fixes, incidents), then hand back a tight current-state brief. Use for 'recall my work on X', 'catch me up', 'what have I been working on', 'where did I leave off', before starting or resuming work.

Capture and analyze GPU frames via the devtools-mcp renderdoc backend (RenderDoc). Use when a graphics app (D3D/Vulkan/OpenGL) renders slowly or wrongly and you need the per-drawcall event tree, GPU timings per draw, the resource inventory, a frame thumbnail, or a GPU-time flame graph, captured headlessly, no RenderDoc GUI required. Covers the capture→analyze→counters workflow, the two capture modes, and the GPU/interactive-session prerequisite.

GPU frame debugging with RenderDoc via rdc-cli. Use this skill when the user mentions: GPU debugging, .rdc files, RenderDoc, shader issues, pipeline state, rendering artifacts, frame capture, shadow problems, visual glitches, draw calls, render targets, pixel history, texture inspection, depth buffer, blend state, rasterizer state, vertex shader, fragment shader, pixel shader, compute shader, mesh output, GPU performance, overdraw, bandwidth, shadow map, PCF filtering, screen-space artifacts,...

Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or external integrations. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services.

Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.

Manage the ai-grind skills library: harvest upstream skills/commands/agents into the catalog, author new skills, and sync the flat mirrors (committed plugin bundle, loadable/, .agents/, project/global .claude dirs) via the skills_sync MCP tool or the scripts directly. Use when adding or editing a skill, when a skill isn't showing up in a session, when asked to "sync the skills", after editing sources.toml, to check what the library contains, or to find skills scattered across the machine that...

Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea.

Link tracker tasks to test outcomes: write acceptance criteria, attach concrete test references (file::test_name), record pass/fail after runs, and work with the close gate (advisory vs strict project policy). Use when defining "done" for a story, after running tests that verify a tracked task, or when a close is rejected by the strict gate.

Decompose work in the devtools-mcp tracker: epics into stories, stories into punch-card subtasks, with auto-tag rules classifying tasks at creation. Use when planning a feature ("break this down", "build me a backlog", user-story writing), when restructuring a tree (reparent/reorder), or when setting up tag rules so new tasks self-classify.

Bridge devtools-mcp tracker tasks to GitHub issues and git history: create a GitHub issue from a task (criteria checklist included), sync remote state and spot drift, close remote issues, and auto-link commits by putting task keys in commit messages. Use when a tracked task needs a public issue, when reconciling tracker vs GitHub state, or when wiring commits to tasks.

Track work in the devtools-mcp tracker, a persistent SQLite-backed mini-JIRA driven entirely through MCP tools. Use when starting or organizing any multi-step coding effort: create a project, file tasks with PROJ-123 keys, move them through the status workflow, and query bounded views (table, tree, rollup). The entry-point skill; see tracker-breakdown, tracker-acceptance, and tracker-github-sync for the deeper workflows.

Interactive cross-language debugging through devtools-mcp's unified debug tools (debug_start/debug/debug_inspect/debug_stop): one verb vocabulary over Python (debugpy), C/C++/Rust (lldb-dap), JS/Node (js-debug), Kotlin/JVM (kotlin-debug-adapter), Java (jdt.ls+java-debug), and ABAP (SAP ADT REST). Use whenever a program needs breakpoints, stepping, variable inspection, watches, or attach-to-process in ANY of those languages, including mixed codebases, instead of print-debugging. Every stop aut...

Profile with Intel VTune Profiler via the devtools-mcp vtune backend: CPU hotspots, threading, memory-access, memory-consumption, microarchitecture (top-down), and the performance snapshot, plus the raw `vtune` CLI for anything deeper. Use when you need Intel-grade depth on Windows or Linux: hardware-event analysis, top-down (front-end/back-end/memory-bound) breakdowns, false sharing, DRAM-bound questions, or when ETW/perf hotspots aren't enough. Follows the Intel VTune Performance Analysis C...

Template any repository (code, documentation, or anything else) so a coding agent finds things without re-searching - root CLAUDE.md + AGENTS.md pointer, a PROJECT_MAP.md that says what lives where and WHY, one CLAUDE.md per major area/module, an engineering-principles doc (DRY, SOLID, KISS, YAGNI, tests), and a local SQLite FTS5/BM25 index (optional embeddings, CLI + MCP tools) with agent notes that go stale when their files change. Use when bootstrapping or retrofitting a project, when aske...

Sync the local devtools-mcp tracker with an llm-station-remote platform (the multi-tenant agent+human collaboration backend) via the station_link / station_sync / station_session MCP tools, including how to get the user authenticated through the browser. Use when asked to "connect to the platform", "sync tasks to the station/server", set up station.toml, push claims/skills/perf runs, coordinate sessions or handoffs across members, or whenever a station tool answers "Not authenticated". For pe...

The adversarial reviewer's checklist for a Venus wave packet, refute the handoff from the diff and the build report: knob and red line per gate, numbers diffed against logs, production-consumer grep, prior findings ledger, Tiger Style greps, lever plumbing, and the structured verdict. Use when reviewing any packet before its per-ticket commit.

Cook and validate Venus assets with venus_cook (.vtex/BCn textures, VAsset containers, the binary manifest) and extend the cooker with new asset types. Use when cooking textures, adding cookable formats, debugging a .vtex/.vasset load, or working on doc-34 asset-pipeline stages.

The single build owner's recipe for a Venus wave, one target per cmake invocation with a survivable tally, the plain-client boot check, serial gates (-j 1) with per-control raw rc + sentinel, the receipt JSON every wave must carry, disk/process hygiene, and what "NOT FINISHED" must say. Use when you are the only agent allowed to build/test after implementers hand off, or when producing the VENG-1583-style receipt for a SHA.

Build Venus targets (CMake/MSVC build-msvc dir) and run demos correctly, target names, config flags, CWD/asset-path gotchas, env vars, and how to capture + inspect a demo frame. Use when asked to build, run, or screenshot any Venus executable, or when a demo "renders nothing"/"can't find assets".

Where code goes in Venus, engine vs game. Use BEFORE writing or placing any rendering/lighting/physics/streaming feature, when reviewing a diff that adds engine-shaped code to src/neon, src/wyrdholm, src/networked_rts, src/demo or examples/, or when deciding whether to promote game code into the engine. Encodes the standing centralisation rule (Ben, 2026-08-14), the LOOK-vs-MECHANISM test, the promotion checklist, and the red-flag list from the 2026-08-14 audit.

How to write a Venus negative control (falsifier) that actually discriminates, explicit atomic setter lever called from main(), one printed sentinel line, PASS_REGULAR_EXPRESSION-only ctest registration (never bare WILL_FAIL), the CTest inversion semantics, and the MSVC env-lever trap. Use when adding a WILL_FAIL twin, when a control passes vacuously, or when a reviewer says "not discriminating".