Vic's Agent Skills
My small collection of Agent Skills for AI coding agents.
Skills
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.
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.
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
....
.::::::::..
.::: ::::'::::
,::::::' `::::
:: ::: `:::.
.:::::_ _::::
.::::: ` -' ::::
.::: :'-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 <system-reminder> 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
| Command | What it does |
|---|
current | Resolve THIS session's JSONL path from $CLAUDE_CODE_SESSION_ID (so you strip the right file, never an mtime guess) |
analyze | Token breakdown by type and tool name, cut points, health check |
strip-tools | Clear tool inputs/results (granular: by tool name, inputs/results only, keep last N lines) |
strip-thinking | Remove thinking blocks |
strip-all | Strip tools + thinking in one pass |
compact | Summarize early messages behind compact boundary, keep recent work intact |
verify | Chain integrity check (parentUuid, slug, timestamps) |
show-tool | List or inspect individual tool calls with context |
persist-tool | Save tool result to file, replace with summary + reference |
persist-tools | Bulk persist (like microcompact, keeps last 3 intact) |
show-thinking | List or inspect individual thinking blocks with context |
persist-thinking | Save thinking to file, replace with summary |
persist-thinkings | Bulk persist all thinking blocks |
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
Serverless local chat between Claude Code, OpenAI Codex and OpenCode 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 <name> escape), drive it with any shortcut (type <name> "/compact" + key <name> enter) — or spawn a brand-new agent into a fresh iTerm window or detached tmux session (spawn <name> --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]). OpenCode (v2) agents join with no setup at all: they register via $OPENCODE_SESSION_ID, and since OpenCode has no hooks, whoever sends them a message delivers it straight into their session through OpenCode's server API — which also wakes an idle one without typing anything.
Codex and OpenCode both run tool commands in a shared background server, so a session's environment says nothing reliable about which terminal it is in. agent-chat finds each agent's pane from evidence instead (process ancestry; for Codex the thread id in the title or launch command, what the pane shows, when the TUI started) and never binds to a guess; setup-codex --title-id makes the Codex case exact.
macOS iTerm2 and/or tmux + jq. Needs three hooks in ~/.claude/settings.json — see the SKILL.md install section.
| Command | What it does |
|---|
register <name> | join the chat (or silently rebind an existing identity to a new session) |
send "msg" [--room r] [--to name] [--nudge] | broadcast to your project room, another room, or DM |
read | print + consume unread from all joined rooms |
rooms / join / leave / peek | mIRC-style room discovery and membership |
who / log | registered agents; room history |
nudge <name> [text] | wake an idle agent (types a prompt into its iTerm window) |
screen <name> [N] | live snapshot of the agent's visible terminal |
type <name> "text" / key <name> <keys...> | remote-drive its TUI: escape, enter, ctrl-c, arrows, tab... |
spawn <name> [--dir d] [--prompt "task"] [--tab|--pane|--tmux] | launch a new self-registering agent — new window, tab, split pane, or tmux session |
status [name] / whereami | live state of an agent (busy · idle · waiting · dead · offline); what this session resolves to |
web [port] | local live web viewer: channels · messages · people with status/unread |
Example ask
Register on agent chat as summarizer
Tell the other agent the DB schema changed — don't touch March 2004 until it confirms
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.
| Command | What it does |
|---|
tasx init | create the .tasx/ tree + convention README + CLAUDE.md/AGENTS.md pointer; git-ignores it locally (--gitignore for the shared file); renames a legacy tasks/ tree |
tasx new "Title" | new task in the inbox (--decision --option "a | Label" for choices) |
tasx list [--all] | kanban to stdout: needs-you / in-progress / inbox / waiting |
tasx move <id> <state> | git-mv-aware state change (--waiting-on for waiting) |
tasx comment <id> "..." --as <name> | timestamped append; nudges the owner via agent-chat |
tasx doctor | staleness report: stale work, dead owners, duplicate ids |
tasx archive | roll done/ files older than 30d into done/YYYY-MM/ |
tasx serve | the board — stable per-project port on 127.0.0.1 |
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
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 <session-id> 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
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 <skill-dir>/scripts/extract.py docs/conversations/ --recursive
# Messages-only view to a specific output directory
python3 <skill-dir>/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).
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 <sessionId>.
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/<encoded-cwd>/<sessionId>.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 <uuid>.
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
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/<conversation-uuid>/ 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/<uuid> (probably need to use chrome)
Pull this ChatGPT conversation's JSON via the API route, with all the attachments
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.
An optional structure layer parses each sentence with spaCy in its own venv and names faults of structure, from a verbless sentence to a wedged appositive. slopcheck install-structure --with-surprisal sets it up and adds GPT-2 surprisal spikes, local and offline. On 54 labelled rewrites it flagged 23 originals and 11 rewrites.
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, scripts/slopmark and scripts/structcheck 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. slopcheck install-structure adds the structure layer. 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).
