Vic’s Agent Skills

My small collection of Agent Skills for AI coding agents.

Skills

layered-summary

Summarizes the whole repo to get a layered overview - each folder will have it’s own AGENTS.md file that will describe what’s contained. The agent starts from the deepest folders, summarizing files, then goes up - summarizing the summaries. This is why it’s called “layered” - AGENTS.md are layered summaries across a subtree (deep dirs are detailed; parents roll up children).

This helps agents working on a big repo to better understand where to look for things.

Best used if you install tree locally with brew install tree

Example ask

Make a layered-summary of `crates/engine`

Example output

Agent creates AGENTS.md like this (in the crates/engine folder, with similar files in each subfolder):

# engine

## Purpose
Top-level engine subsystem directory: contains the crates that implement reth’s Engine API handling, live-sync “engine tree”, orchestration/persistence wiring, and supporting utilities for testing/debugging.

## Contents (one hop)
### Subdirectories
- [x] `invalid-block-hooks/` — Debugging hooks for invalid blocks (e.g., witness generation via `InvalidBlockHook`).
- [x] `local/` — Local/dev-chain components that generate Engine API traffic (`LocalMiner`, payload attributes builder).
- [x] `primitives/` — Shared Engine API types/traits/events/config (`BeaconEngineMessage`, `ConsensusEngineEvent`, `TreeConfig`).
- [x] `service/` — `EngineService` wiring that composes engine-tree + downloader + pipeline backfill into a pollable service.
- [x] `tree/` — Core `reth-engine-tree` implementation (Engine API request handling, in-memory tree state, backfill, downloads, persistence).
- [x] `util/` — Stream utilities around engine message streams (store/replay/skip/reorg simulation).

### Files
- (none)

## Key APIs (no snippets)
- **Main building blocks**:
  - `tree/` — `EngineApiTreeHandler`, `BasicEngineValidator`, `ChainOrchestrator`, `PipelineSync`, `PersistenceHandle`
  - `service/` — `EngineService`
  - `primitives/` — `BeaconEngineMessage`, `ConsensusEngineHandle`, `ConsensusEngineEvent`, `TreeConfig`

## Relationships
- **Integrated by**: node launch/wiring layers outside this subtree (Engine API RPC ingress → engine message stream → engine service/tree).
- **Design intent**: keep Engine API responsiveness high by minimizing DB writes on the critical path and delegating persistence/pruning to background workers.

repomix-analysis

Ask your repo things for free and with huge context. This skill uses Repomix to pack a repo or a subset of interest into an AI-friendly file for whole-codebase, cross-file analysis. After packing, the agent gives you a question-prompt that you can paste to a free Gemini 3 Pro Playground along with the packed context file (Gemini 3 Pro supports up to 1 Million tokens context and is 100% free from the web Playground).

To the contrary of modern agents that read files L1-200 lines at a time, this helps if you want to investigate huge repos, find dependencies, see the architecture at a whole, or just ask “how does this thing work in this repo?” without missing anything important.

Best used if you install Repomix locally with brew install repomix.

Example ask:

How does peer persistence work (disk format + lifecycle) in reth? I want how peer records are stored, loaded on startup, updated during runtime, and any pruning/expiration behavior. Use repomix-analysis skill for this and verify its claims manually later.

Example answer

The model will pack relevant information and present you with the following:

Repomix pack is ready at `reth/repomix-peer-persistence.xml ` (≈833k tokens; excluded `crates/net/eth-wire/testdata/**` and mdx/assets to fit size).  

Please upload that file to Gemini and run this prompt, then paste the result here so I can verify it against the repo:

```
You are analyzing a repository packed by Repomix (attached).
Use the attached Repomix file(s): repomix-peer-persistence.xml.

Task:
Explain how peer persistence works in reth: disk format + lifecycle. Include how peer records are stored, loaded on startup, updated during runtime, and any pruning/expiration behavior.

Constraints:
- Cite file paths for every non-trivial claim.
- When reasoning about behavior, trace cross-file call paths and data flow.
- Avoid speculation. If information is missing or ambiguous, state what’s missing and what additional pack/file would resolve it.

Output format:
- Summary (3–7 bullets)
- Key files/modules (path → responsibility)
- Detailed analysis
- Actionable next steps / follow-up questions (only if needed)
```

Once you paste the Gemini output, I’ll manually verify the claims in the codebase and deliver the final answer.

Then just copy the prompt into a big model and get the answer back to the Agent for verification.

init-context

Build a complete mental map of a project through phased exploration. The agent reads root-level docs, spawns sub-agents to explore major source directories / tests / CI / GitHub history in parallel, fills gaps, and synthesizes a full project briefing — architecture, open work, developer guide, and a “where to find things” quick reference.

After this runs, the agent has full project context and shouldn’t need to rediscover anything.

Example ask

Explore this repo and give me a full briefing

Init context — I want to start a deep work session on this codebase

session-stripper

             ....
           .::::::::..
         .::: ::::'::::
         ,::::::'  `::::
         :: :::     `:::.
        .:::::_     _::::
       .:::::  `  -' ::::
      .::: :'-o-  -o-::::.
      ::: ::         |:.::
      ::::::     >   |::.:.
      `: :::     __   :::.:
      .:::::\   --' / :::::.
      ::: :: `-._.-. .::::::
     .::::::      | . :::.::
     ;:.::::.     |. .:::.::.
   _.::.:::::     | `..:::.::
  /.;::.: :::-._  \  :::::::'
 / ::::. :::.        ::::.::
.  :::::.::::.       `:::....
|  :::.:.:::::        :::::::
|  ::::::.:.:.         `::.::
|  `:.: ::::::.         .::::.
`.  ::::::::.::        .:.:::.
 | ::: :::::::'       .::;:::'
 | `:: :::.:::  '     ::::.::
 |  `::: :..:: /   \  :: ::::
 |   `::::::::/     \ ::.::::
 |    `::::::::      `-`:::::::'
 |    ||     ``           | ``'
 |    |`                  |\
 `.   | \                 \ \
  |  _|  \                 \ `-
  |   \   \                 \  `\
  |    \  |                  \   \
  `.   |  |                   >-  \
   |   `  |        o)        /_    )
   `    | /                 |/ |   |
    \   | |                    ||| |
        ` |                   //////
     \   ||                _-//////\
      .  `|              .'  \//// .
      `   \        ___.-'    /`-'  |
       \   \`-----'         /      |
       `    \_     :F_P:   /       |
        \     `\ _        /        |
         \    <\\ `-__.-|'        .'
        / \    \\>  |   `.        |
       /  |   . \   '    |        |
      /   \\ \ \ \ /     |        |
           \\ \ -//      `.       |
     /      '`-.//        |       |
    /           /         |       |

CLI tool for trimming Claude Code JSONL sessions that hit “Prompt is too long”. Strips tool content (60%+ of context), thinking blocks, images, and superseded attachments — or persists them to files with AI-generated summaries. 13 commands, no external dependencies (Python 3.8+ stdlib only).

strip-attachments targets the context nobody counts: attachment lines are not transcript metadata, they’re re-expanded into a `` on every request and never deduped — a long session can carry 100k+ tokens of stale todo snapshots and hook echoes. They’re also parentUuid chain participants, so deleting them naively leaves a file that parses fine while CC silently loses everything older than the first deleted line; the command re-parents every child.

Full technical deep-dive in references/surgery-report.md.

Commands

Example ask

My session is hitting "Prompt is too long" — help me strip it

Analyze this session and tell me where the tokens are going

agent-chat

Serverless local chat between Claude Code sessions running concurrently on the same machine — stop being the copy-paste relay between your own agents. Rooms are plain JSONL files (no daemon): every agent auto-joins its project room (derived from its cwd, so agents in the same folder share a channel with zero config) plus #general; DMs land in the room both agents share (project room first, #general only for cross-project). Unread messages are auto-delivered into each session’s context by three hooks (mid-turn after tool calls, at turn end, and with your next prompt), with per-agent read cursors — a busy or crashed agent picks up its full backlog when it comes back.

Identity is the name, not the session: re-registering the same name after a fork/strip/restart silently rebinds it — cursors kept, no join announcement, peers can’t tell the transition happened.

Also includes remote control of peers by typing into their terminals: wake an idle agent (nudge), watch what one is doing right now (screen — spinner, running tool, stuck permission prompt), stop a runaway one (key escape), drive it with any shortcut (type "/compact" + key enter) — or spawn a brand-new agent into a fresh iTerm window or detached tmux session (spawn --prompt "task"); it inherits your CLI flags and registers itself in the chat.

Two terminal backends, auto-detected per agent: iTerm2 (AppleScript) and tmux (send-keys/capture-pane) — the tmux backend works fully headless, e.g. agents on a Linux server over SSH. The chat core itself is plain bash+jq+files and runs anywhere.

Cross-CLI: OpenAI Codex agents (CLI >= 0.145, which ships a Claude-Code-compatible hooks system) join the same rooms — agent-chat setup-codex wires the hooks, Codex sessions register via $CODEX_THREAD_ID, and Claude and Codex agents chat, nudge, and remote-control each other seamlessly (who tags them [codex]).

macOS iTerm2 and/or tmux + jq. Needs three hooks in ~/.claude/settings.json — see the SKILL.md install section.

Example ask

Register on agent chat as summarizer

Tell the other agent the DB schema changed — don't touch March 2004 until it confirms

tasx

File-based task tracker for AI-agent projects: markdown files are the source of truth, the folder is the state. The root of .tasx/ is the inbox; agents move files between in-progress/, waiting/, done/, cancelled/ (a status change is just mv), and decisions/ holds open choices with radio options. The folder is hidden and git-ignored per repo (tasx init adds it to .git/info/exclude), so it never shows up in the project’s commits. No database, no daemon, no dependencies (Python 3.8+ stdlib): ls .tasx/in-progress/ is a kanban.

tasx serve gives you a zero-dependency local board over the same files — Needs you pinned on top with the count in the tab title, in-progress cards with owner liveness dots (via agent-chat status), ⚠ stale chips (in-progress >24h, waiting-on-you >3d, inbox >14d), a “since your last visit” digest, and a collapsed done archive grouped by day. Every click writes straight back into the md files: the status dropdown physically moves the file, decision radios write choice:, comments append to ## Comments — and each nudges the owning agent through agent-chat, so answering a question on the board resumes the work.

The SKILL.md doubles as the agent contract: run tasx doctor at session start and reconcile, own what you work on, file blockers as waiting/ or decisions instead of idling, comment on finish. Reads legacy folders (myhdd-style YAML frontmatter, blocked/) as-is.

Example ask

Init a tasks folder in this project

What needs me? Serve the task board

You're blocked on my choice — file it as a decision and move on

respawn

Companion to session-stripper: stripping shrinks the session file on disk, but only a CLI restart loads it as the new, smaller context — and an agent can’t relaunch itself. This skill can: a detached watcher types /exit into the agent’s own iTerm window (queues politely if a turn is still running), then relaunches with --resume and a kickoff prompt so the agent continues where it left off.

The relaunch command is rebuilt from the live process: all flags are preserved (--dangerously-skip-permissions, --model, …) except session selectors (-r/--resume, -c/--continue, --session-id, --fork-session, --from-pr), which are stripped so a stale selector can’t resume the wrong session. Defaults to the current session id (in-place strips); pass the new id after a forked strip. --dry-run rehearses everything without touching the window.

iTerm2 or tmux (works headless, e.g. Linux servers). Watcher log at ~/.claude/respawn/respawn.log.

Example ask

Your context is almost full — strip your session in place and respawn yourself

ai-conversation-extractor

Convert AI conversation JSONL transcripts (Claude Code, Codex CLI, ChatGPT/Gemini) to clean, readable Markdown. Strips binary blobs (base64 images, PDFs — typically 95%+ of file size) while preserving the full human-readable conversation: user messages, assistant text, thinking, tool calls, and tool results.

Supports four auto-detected formats: Claude Code sessions (~/.claude/), Codex CLI sessions (~/.codex/), Codex history prompt logs, and ChatGPT/Gemini simple exports. Also includes a messages-only mode (--ua-final-only) that keeps just user prompts and final assistant responses — useful for clean conversation summaries.

Includes a detailed JSONL format reference documenting record types, content blocks, and folder structures.

No external dependencies — uses only Python 3.12+ stdlib.

Example ask

Convert my Claude Code conversations in docs/conversations/ to readable Markdown

Convert my Codex sessions to messages-only Markdown in ./converted/

Example usage

# Full conversion (all formats auto-detected)
python3 /scripts/extract.py docs/conversations/ --recursive

# Messages-only view to a specific output directory
python3 /scripts/extract.py ~/.codex/sessions/ --out-dir ./converted/ --ua-final-only

Converts a 34MB JSONL transcript to ~670KB of readable Markdown (1.7% of original).

claude-desktop-chat-export

Export a claude.ai (Claude Desktop / web) conversation and convert it to a Claude Code CLI JSONL session, so it becomes resumable via claude -r .

claude.ai chats aren’t resumable — once you hit the context limit or close the tab, the conversation is read-only. Claude Code CLI stores every session as JSONL at ~/.claude/projects//.jsonl and resumes on demand. Same underlying model; only the harness (system prompt, tools, output length) differs.

The skill walks you through: (1) grabbing conversation.json + images from the browser console at claude.ai (or via the claude-in-chrome MCP + bundled scripts/relay_server.py), (2) organizing them locally, (3) running scripts/convert_to_cli.py to produce a CC-compatible JSONL, (4) resuming with claude -r .

No external Python dependencies — stdlib only (Python 3.10+).

Example ask

I hit the context limit on this claude.ai chat — help me continue it in Claude Code

Export this Claude Desktop conversation and import it into CC

chatgpt-chat-export

Export a chatgpt.com (ChatGPT web) conversation to disk with full fidelity: the raw /backend-api/conversation/{id} JSON, every attachment (user-uploaded images, PDFs), and a readable Markdown transcript with attachments linked inline.

ChatGPT’s built-in export mails you a zip of everything, hours later. The page’s own API returns one conversation instantly — but getting it (and the attachment bytes) out of an authenticated browser is an obstacle course: the MCP extension truncates and DLP-filters JS results, uBlock blocks localhost relays, attachment URLs aren’t signed so curl fails, and Chrome swallows repeated programmatic downloads. The skill encodes the working paths around all of that — clipboard transport via an injected button + real click for MCP-driven exports, Blob downloads for manual DevTools use — plus scripts/chatgpt2md.py, which walks the canonical branch of ChatGPT’s mapping tree (not a flat list), drops tool/reasoning scaffolding, and strips the private-use-area citation runes.

Output lands as chat-exports// with conversation.json, conversation.md, FILES.md, and files/.

No external Python dependencies — stdlib only (Python 3.9+).

Example ask

Please grab this talk from ChatGPT: https://chatgpt.com/c/ (probably need to use chrome)

Pull this ChatGPT conversation's JSON via the API route, with all the attachments

slopcheck

Keeps an agent’s writing readable for one specific reader, as a named list of rule breaks instead of a score. A standard-library Python checker plus five Claude Code hooks:

• a reminder line with the rules on every prompt, built from the config thresholds
• one advisory line under every reply of 60 words or more
• the named list into the agent’s context after it writes any document
• a deny gate on publishing an artifact whose prose has an em-dash or an en-dash
• a deny gate on Slack, pull-request, Linear and Notion text until the list is empty

Checks sentence length, comma count, semicolon chains, em-dashes and en-dashes, lists run inline, paragraph and bullet length, fact-carrying parentheses, achievement words for unfinished work, agreement openers, sign-post phrases, contrast frames, and an advisory list of terms whose first use has no gloss. An optional model layer, off by default, adds inflation, unexplained jargon, bare numbers and metaphors, through the Anthropic API or the TypeSafe Jev API.

Example ask

Install slopcheck and enforce my writing rules on final messages, docs and Slack drafts.

Example output

Style check: 3 rule breaks: sentence of N words, list of N or more run inline, paragraph of N sentences. 1 style flag: achievement word.
Rule breaks:
  - sentence of 41 words: "The new service handles retries, batching, backoff and metrics, and it also owns the schema mi"
  - list of 3 or more run inline: "The new service handles retries, batching, backoff and metrics, and it also owns the schema mi"
  - paragraph of 5 sentences: "The rollout starts on Monday."
Style flags:
  - achievement word "shipped": "We shipped the migration last week and the dashboards converged"

Install

Symlink skills/slopcheck/scripts/slopcheck and scripts/slopmark onto your PATH, then run slopcheck install. It backs up ~/.claude/settings.json and ~/.claude/CLAUDE.md, wires the hooks and the reminder, and writes the rules block into CLAUDE.md between markers. The full steps and the config are in the skill.

Install / use

Cursor

Cursor discovers skills from .cursor/skills/ (project) or ~/.cursor/skills/ (user/global).

Claude (Claude Code)

Claude discovers skills from .claude/skills/ (project) or ~/.claude/skills/ (user/global).

Codex (OpenAI)

Codex discovers skills from .codex/skills/ (project) or ~/.codex/skills/ (user/global).

Then open agent chat and ask for something related to a skill (or invoke the skill explicitly).