Real-world reviews of AI repos, plus our own test results.

A Claude Code plugin marketplace and set of setup scripts called the hogwarts spellbook. Protego Totalum turns on the sandbox in strict mode and installs a hook that blocks reads of .env files, keys and cloud credentials. Imperio adds path-scoped style rules, Revelio lists failed tool calls, and Felix Felicis audits repo setup. The hook we tested first shipped as emaarco/agento-patronum; its author folded it into this repo, inside Protego Totalum, and the old URL no longer works.

A Claude skill that finds the habits AI leaves in English prose, like vague sourcing, puffed-up importance and stock phrases, and rewrites them. It keeps the facts as they were, matches a sample of your own writing if you give one, and leaves code, tables and links alone. The idea of a fixed checklist of AI tells, plus a second pass that checks the rewrite against the source, is worth borrowing.

A set of short, editable SKILL.md prompts for engineering work. They cover grill-me style interviews about a plan, a shared CONTEXT.md glossary, a red-green-refactor TDD loop, and a per-repo setup for issue tracker and labels.

An API, hosted or self-hosted, that turns a web page or a search query into markdown, JSON or a screenshot ready for a language model. It can crawl a whole site, list its URLs without fetching them, and click or scroll through a page before reading it. It also converts PDF and DOCX files to markdown.

A Python command-line tool and library that converts PDFs, Word, Excel, PowerPoint, HTML, CSV, JSON, EPUB, ZIP archives and YouTube links into Markdown text. Headings, lists, tables and links are kept, so the output is easier for a model to read.

The Hugging Face library that defines the shared model code for text, vision, audio and multimodal models. You can load a model from the Hub in one line, use a high-level pipeline for quick inference, and training and serving engines build on the same definitions.

A self-hosted chat interface for LLMs. It runs local models through Ollama or any OpenAI-compatible API, lets you upload documents into a knowledge base and chat over them, and installs with pip or Docker.

A roster of role prompts, such as frontend developer, backend architect or security reviewer, each with its own working style and steps. An installer script copies them into Claude Code, Cursor, Copilot and other tools, and a desktop app lets you browse them.

A skill for coding agents that pushes them to build company websites that look designed rather than like a template. It picks the page type, palette, font pairing and hero layout, then checks the page in headless Chrome.

A browser workspace where you give a brief and a coding agent builds an interactive prototype with a live preview, plus slides and short motion videos. It plugs into coding agents you already run, such as Claude Code, Codex or Cursor.

A Claude Code skill, with matching versions for other agents, that makes the model answer in terse fragments with no filler, while code, commands and error text stay exact. Companion commands write short commit messages and one-line review comments, and another compresses memory files such as CLAUDE.md.

An open-source Python library for building and training neural networks, with tensor math that runs on GPUs. It records operations as they execute, so you can step through a model while it runs.

The reference collection of MCP servers, showing how to hand a model tools and data. Each server runs as a local subprocess over stdio, so it opens no network port. It covers web fetching, file access inside folders you allow, git repositories, a memory graph, and a test server that exercises every feature.

A self-hosted AI workspace run from Docker. You can chat with local or API models that use tools, MCP and skills, and it adds multi-step web research, a document editor, an email inbox with AI triage, notes, a calendar, and blind side-by-side model comparison.

A self-hostable chat interface that works with many model providers from one screen. It is moving toward agents that join team chat tools, take on tasks and run several at once.

A Python crawler built on Playwright. It opens pages, including JavaScript-heavy ones, and returns clean Markdown ready for an LLM. It can crawl deep with BFS or DFS, resume after a crash, and extract fields with a model.

A Node and React control panel for a team of agents. You hire agents such as Claude Code, Codex or a bash script, give them roles and tasks on an org chart, and set a monthly budget that stops work when it runs out. Every tool call and approval is logged.

A skill that draws diagrams as one HTML file with inline SVG, covering about fifty types such as architecture, sequence, ER and timeline. It can pull palette and fonts from a website so the output matches a brand, and it can convert draw.io, Mermaid, Excalidraw or PlantUML sources. It installs into several coding agents.

An agent system for job hunting. It reads job posts, scores each offer on a fixed set of criteria, drafts a CV tailored to each posting, and looks up who to contact at the company, running several agents in parallel.

A gateway that puts one endpoint in front of hundreds of models from dozens of providers. It picks a route by a chosen strategy such as cost or latency, falls back when one fails, and compresses prompts and tool output to cut tokens.

A Python framework for building data pipelines whose results update themselves when new or changed rows arrive. The engine underneath is written in Rust, and the same code runs on a static file or a live feed. It also includes helpers for LLM calls, embeddings, text splitting, and an in-memory vector index for retrieval.

A Python framework for building teams of AI agents, where each agent has a role, a goal and tools. It adds event-driven flows that mix plain steps, single model calls and whole crews. It also ships a plugin and skill package that teaches coding agents its patterns, while tracing and governance sit in a paid layer on top.

A native AI agent that runs as a desktop app or a terminal command. It connects to more than fifteen model providers, from cloud APIs to Ollama, and gains abilities through MCP extensions. Teams can ship their own branded build with the providers fixed.

A terminal tool that pair-programs on a git repo: it reads a map of the codebase, sends the files you pick to an LLM, and commits each edit so you can undo it. After every change it runs your linter and tests and feeds any failures back.

A framework that wraps existing desktop software, such as Blender or Obsidian, into command-line tools an AI agent can call, with structured JSON output. It also has a registry where community-built CLIs install with one command.

A single Rust terminal program that keeps coding agents running in panes, so they survive a dropped SSH session. It marks each pane as working, blocked or idle, and agents can open panes and message each other through a CLI or socket.

Builds a local graph of a codebase showing which functions call which, what depends on what, and what a change would touch. Coding agents query it over MCP, so they can ask about impact without reading whole files.

A Python library for building long-running agents as graphs of steps that share one state. A run can pause so a person can inspect or edit state, survive a crash, and resume from the last finished step.

A personal AI assistant app that keeps memory in a local SQLite store, mirrored as Markdown you can edit. It has agents that sort incoming items, work toward goals in the background, and connect to many apps through MCP and OAuth.

A self-hostable assistant that answers questions over your own files, notes and the web. It can run custom agents and scheduled research that lands in your inbox, and it works with local models or cloud APIs. Front ends include a browser, Obsidian, Emacs and phone.

An open-source server for tracing and evaluating LLM and agent calls. It records what each call did and what it cost, versions prompts, and runs evaluations. You can self-host it or use the cloud version.

A web diagram editor where you describe a diagram in plain language, or upload an image or PDF, and an AI model writes the draw.io version. You can edit it, keep version history, and use it as an MCP tool from Claude Desktop, Cursor or VS Code.

A routing library of 41 rules and about 42 skill modules that tells an AI agent which method to use for reverse engineering, pentesting, CTF, malware analysis, and firmware or API work. It checks which tools are installed and runs a scope check before starting.

A plugin for Claude Code that sends code reviews and coding tasks to OpenAI's Codex without leaving the Claude Code session. It can review uncommitted changes or a branch diff, hand off an investigation or fix, and check on or cancel background jobs.

A Python and React framework for building LLM trading agents. It has connectors to a few brokers in paper and live modes, backtesting, and a way to route agent output to chat apps such as Telegram or Slack. A pre-trade advisory check and a kill switch exist but are opt-in.

A Python agent harness built on LangGraph. It adds planning, sub-agents with their own context window, a file and shell layer, and automatic summarising of long threads. Any tool call can be set to wait for approval before it runs.

Turns a book or document (PDF, EPUB, DOCX, Markdown, HTML) into an agent skill: a short core file with the main ideas, plus chapter files the agent opens only when a question needs them. The output works with Claude Code, Copilot CLI and Amp.

A TypeScript framework for building agents and step-by-step workflows. It includes tools, memory, pause-and-resume for human approval, evals, and support for writing MCP servers.

A local proxy that speaks the OpenAI API format and forwards each request to one of many model providers. When a subscription runs out of quota it falls over to a cheaper or free model, and it compresses large tool output before sending.

A persistent memory layer for coding agents. It saves observations such as facts, decisions and errors, then recalls them later with keyword search plus optional vector search. Tools go out over MCP, and it runs as a local server with no external database.

A CLI and Node library that runs your prompts across several models and checks the answers against a test matrix written in YAML. It also runs red-team scans that throw hostile inputs at an LLM app and report which ones got through, and it can fail a CI build when a prompt change makes results worse.

A large pack of ready-made skills for Claude Code and other coding agents, covering engineering, marketing, product, finance and more. Each skill has its own instruction file and helper scripts, and a converter reshapes them for other tools.

A plugin of about 28 Claude Code skills that runs engineering work as a loop: brainstorm, plan, work, simplify, review, then save what was learned into docs/solutions so the next loop starts from it. It also includes skills for ideation, debugging and explaining code.

Browser automation where a vision model looks at the page and decides what to click or read, so you don't write fixed selectors. It comes as a Python SDK on Playwright, with a Docker setup and a no-code workflow builder.

A small Python harness that connects a coding agent such as Claude Code to the Chrome you already have open and signed in, over the DevTools protocol. When the agent lacks a helper function, it writes one into its own workspace and keeps going. It also ships an MCP server so other clients can use the same browser tools.

An open-source SEO tool with a web UI and an MCP server, so an agent can pull keyword, ranking and competitor data directly. The data comes from a paid API billed per query, and it ships a few ready-made agent skills.

A single-file memory store for agents. Text, embeddings and the search index all sit in one portable file, so there is no database server to run. Earlier states stay queryable, so an agent can look back at what it knew at a given point.

A TypeScript platform for running long tasks, such as the steps of an AI agent, without serverless timeouts. Failed runs retry, a task can pause for a human to approve, and every run has a trace in the dashboard.

A web research service you can self-host with Docker. It exposes connectors for sites like Reddit, YouTube, Google Maps and search as structured data, reachable from an agent over MCP or a REST API, and saves findings to a searchable store with sources attached.

An agent that works directly on your own computer. It can use your browser, run terminal commands, read and edit files, move the mouse and type, and control an Android phone over ADB. Each task it finishes is saved as a reusable skill, so its skill set grows as you use it.

An on-device text-to-speech library that runs ONNX models offline, with a 99M-parameter model and 31 languages. Development ended in July 2026, and the repo is being archived, so it will not get further updates.

A plugin for Claude Code and other MCP-capable coding agents that builds a searchable index of your repository in a vector database. The agent can then ask questions in plain language and receive only the code chunks that match, rather than opening whole files.

A Claude skill that audits a codebase without editing it, checks every cited line to drop false alarms, and writes one plan per finding you pick. A cheaper agent can then run a plan in a separate git worktree, and the skill reviews its diff before you merge. Letting a strong model write precise plans while a cheap one carries them out is worth borrowing.

A VS Code extension and a small local web app that show each Claude Code terminal as a pixel-art character in an office. You can see which agent is busy, which one is waiting for input, and reopen an earlier session from the same view.

A self-hosted accounting app that reads photos or PDFs of receipts and invoices with an AI model, then pulls out the date, merchant, amounts, taxes and line items. It handles many currencies, converts them at the rate from the transaction date, and exports to CSV with the original files attached.

A coding model with a terminal writes Playwright scripts to drive a browser, runs them, reads the screenshots and logs, and fixes them when they break. A solved task can leave a script that reruns without a model.

A command-line tool plus a set of skills that let a coding assistant scaffold an agent project, score it with automated evals, and deploy it to Google Cloud (Cloud Run, GKE, or Agent Runtime).

An agent system that tries to run a research project from start to finish: it reads the papers you supply, proposes ideas, writes and tests code for them, then drafts a paper from the results. It has a web interface and can run in a Docker image.

A self-hosted chat over your own documents. You upload files, they are parsed and indexed in OpenSearch, and a Langflow retrieval flow answers questions about them. It also exposes its functions as MCP tools.

A markdown editor that edits like a doc editor but saves plain .md files. It has a file tree, search, wiki links and a graph view, and it connects Claude, Codex or Cursor to your folder through MCP. Team sharing runs through git.

A gallery of animated pixel pets for Codex, with a one-line CLI to install one and a small desktop window that floats the pet on screen and reacts while the agent works.

A set of agent skills that produce game-ready 2D sprites, animated sheets and layered tile maps. The model plans the look and composition, then plain local Python cleans the chroma-key, slices frames, checks them and exports to Godot, Unity or raw 2D.

A set of skills and a small npm CLI that hand a coding agent short, expert-written guides on current web platform features, such as native dialogs or container queries. It also has a legacy-scan command that flags older JavaScript patterns in a codebase.

A set of Claude Skills for a trading routine: a daily market check, a weekly portfolio pass, a monthly review, and a trade journal with postmortems. The skills structure your decisions and do not place trades.

A background daemon that rewrites an agent's skills from its real sessions, then shares one skill library across several agent tools. A local dashboard shows the skills and their version history.

A single .agent/ folder that holds your memory, skills and rules, and carries them between coding agents such as Claude Code, Cursor, Codex and Gemini CLI. It also ships a runner that executes a goal as a dependency graph of agent steps, and a local dashboard that shows what the agents are doing and what they cost.

A Pi extension that gives an AI agent eyes and hands on a desktop. It lists open windows, reads what is visible in them, finds buttons and text, then clicks, types, scrolls and waits for the screen to change instead of guessing with sleeps. It works through each operating system's accessibility layer, with a small helper app on macOS.

An MCP server for Claude Code that indexes your code by function and class, so the agent asks for one symbol instead of opening whole files. It also installs hooks that shrink noisy output from commands like git, pytest and docker.

A small MCP server that makes a model think in named stages, from defining the problem through to a conclusion. It can revise an earlier step or branch a new path, and it saves the whole session to a file so a crash does not lose it.

A typed JavaScript and TypeScript bridge that lets a coding agent call Chrome DevTools Protocol methods directly, keeping one connection open between snippets. It can attach to a Chrome you already have running.

A permission guard for coding agents. It sorts each action by what it does, such as deleting files, sending data out or rewriting git history, rather than by command name, then allows, asks or blocks it under fixed rules. An optional model step handles only commands it does not recognise.

A macOS menu bar app that keeps the Mac awake only while a coding agent is working, including with the lid closed. When no agent session is running, the Mac sleeps as normal. It hooks into the CLI tools of several coding agents.

A Python layer that runs every tool call an agent makes through a set of checks: risky shell commands, secret exposure and path traversal get flagged. Rules live in one YAML file, and each decision goes to an audit log.

A pixel-art virtual office in the browser where agents running on local models walk to desks, message each other, assign tasks and hire new team members. Each agent thinks roughly every fifteen seconds, uses small tools like web search and notes, and keeps memories in SQLite. It runs on Ollama, with an OpenAI-compatible option.

A macOS menu bar app that watches your Claude Code sessions as they run. It shows estimated spend, the files each session touched, and flags credentials that show up in session content.

A command-line index of agent skill files, pulled from GitHub and some research sources, that works offline once downloaded. You search it and install a skill straight into your Claude Code or Cursor skills folder.

A copy-in set of Claude Code config files: a CLAUDE.md with behaviour rules, a dozen preset agents, hooks and skills, plus rules that apply only to certain file paths. You drop them into .claude in a project or into ~/.claude for all projects, and pick a preset that fits the project's size.

A local dashboard for Claude Code usage. It reads your session files, charts spend per project, and flags likely waste such as repeated file reads, expensive outliers and very long sessions. According to the README it makes no network calls.

A set of Claude Code hooks plus a few slash-command skills. The hooks block risky actions such as destructive git commands and prompt injection, and warn when context is running out, even when permission prompts are bypassed. The author says the deny rules hold near-perfectly, which is their own claim.

A bot that reads a pull request's diff with an LLM and posts review comments, plus describe and ask commands. It runs on GitHub, GitLab, Bitbucket and Azure DevOps, and is a fork of CodiumAI's PR-Agent.

A multi-agent tool that sends one question to a panel of named thinker personas across several model providers, then runs a few rounds of cross-examination. It requires some dissent, so one confident answer does not pass unchecked.

A self-hosted web app that puts several coding agents, including OpenHands, Claude Code, Codex, Gemini and anything that speaks the ACP protocol, under one interface. It runs on your laptop, a server or the cloud, and can start agents on a schedule or from a webhook such as a Slack or GitHub event.

An open-source bot that reviews pull requests. Comment commands such as /review, /describe, /improve and /ask post structured feedback straight onto GitHub, GitLab, Bitbucket, Azure DevOps or Gitea. It runs from CI, a webhook, the CLI or Docker and works with many model providers through LiteLLM.

A document parser that turns PDFs, Word and PowerPoint files, spreadsheets, HTML and XBRL financial reports into Markdown, JSON or other structured formats. It keeps tables, reading order and formulas intact, can use vision models for scanned pages, and ships with LangChain and LlamaIndex integrations plus an MCP server.

A Claude Code skill that makes the agent write less code. Before writing anything, it climbs a short ladder: skip it, reuse what exists, use the standard library, then a one-liner. The README's benchmark reports fewer lines and tokens on a FastAPI project with validation kept intact.

An open-source gateway and observability layer for LLM calls. You point requests at its endpoint, and it logs each call, tracks token use and cost per model, traces multi-turn sessions, and can fall back to another provider. It can be self-hosted with Docker or Helm.

A set of Claude Code skills for making content: article cards in several cartoon or sketch styles for Xiaohongshu, infographics with about twenty layouts, illustrations for articles, and a publisher for WeChat Official Accounts. Each skill installs on its own.

A desktop and self-hosted app for chatting with your own documents, with a no-code agent builder and one place to switch between many model providers, local ones included. It supports several users, each with their own workspaces.

A command-line scanner that checks a git repo, or your own machine, for API keys leaked into chat and shell history and for risky AI config files, such as Claude Code hooks that run shell commands. It can redact the keys it finds and writes reports as JSON, HTML or SARIF.

An npm package that gives an agent layered memory. It turns long task state and tool output into a diagram of short symbols, keeps the raw logs in storage, and can trace any symbol back to its full text.

A sandbox runtime built on Rust and KVM that runs untrusted agent code inside its own small virtual machine, booting in under 60 ms. It is compatible with the E2B SDK, so code written for E2B can move over.

An LLM agent that runs a penetration test from a plain-language goal: recon, finding weaknesses, exploiting them, then a report. It stops once the goal is reached, and a flag only counts when it shows up in real tool output.

A command-line tool that reads your project's stack, keeps its context in one versioned .faf file, and exports that as CLAUDE.md, AGENTS.md, GEMINI.md or .cursorrules. It also checks how complete the context is and can keep the files in sync with a pre-commit hook.

Turns PDFs and scanned or image-only documents into clean markdown. It runs a 7B vision-language model, so it keeps tables, equations, handwriting and multi-column layouts, and it drops repeated headers and footers.

A methodology packaged as markdown rule files that steer a coding agent through three phases, from planning to building to running, with a human sign-off at each gate. Extra rule sets for security, testing and resilience load only when a request needs them.

An open-source AI agent that runs as a desktop app, a command-line tool or an API. You pick from many model providers, and it extends with MCP tools for code, workflows and research.

A Claude Code skill that edits video from a chat. You drop raw footage in a folder, and it transcribes, cuts silences, grades colour, burns in subtitles and adds overlays, without presets to set.

A GUI agent stack where a vision model looks at your screen and clicks, types and browses on your behalf. It comes as a desktop app and as a CLI with a web UI, and it can plug in MCP tools.

Hooks at the end of a session and before compaction send the transcript to the Agent SDK, which pulls out decisions, lessons and gotchas into daily logs. Once a day those logs get compiled into linked markdown articles that Claude searches through an index file.

A sandbox runtime for running AI-written code in isolated machines that start in tens of milliseconds. Each sandbox has its own filesystem and network, and snapshots let an agent pick up where it left off. The project is archived, so no new fixes are coming.

A library that forces a language model's output to fit a schema, a regex or a grammar. It limits which tokens the model may pick at each step, so the result parses every time.

A catalog of about 245 AI agent skills, gathered from an awesome list on a daily crawl. It checks each SKILL.md format, sorts the skills by job, and exports the list as JSON or CSV.

GitHub's official MCP server. It lets an AI agent in your editor read repositories, search code and commits, open and triage issues and pull requests, check Actions runs and review security alerts.

A Claude Code skill that turns a folder of code, docs, PDFs and images into a searchable knowledge graph. Each link is tagged by where it came from: found in the source, guessed, or unclear. It can rebuild when files change.

A tracing and evaluation library from Weights & Biases. A decorator on your LLM functions logs each call's inputs, outputs and nesting into a trace tree, and you can then score runs against a fixed set of examples.

An open-source platform where agents generate images and videos, schedule posts to about ten social networks, reply to comments with an LLM, and expose an MCP interface. It also has a marketplace where creators earn for brand tasks.

A Rust command-line tool that sits between a coding agent and the shell and trims command output before the agent reads it. It keeps failing tests only, groups diffs by file and drops repeated headers. It installs hooks for several coding agents, so the trimming runs without the agent asking, and it reports how much it cut.

A Claude Code plugin that watches what the agent does during a session, squeezes it into short notes, and feeds the useful ones back the next time you start. You can search past notes by ID and mark parts of a session as private so they are never stored.

A visual editor for AI workflows: drag components onto a canvas, wire them together, test step by step, then publish the flow as an HTTP API or an MCP server. Every component can still be edited in Python.

A local layer that shrinks what goes into an LLM. Tool output, logs, RAG chunks and files are compressed by content type, and the original is kept so the model can fetch the full text back when it needs it. It comes as a library, a proxy, an agent wrapper or an MCP server.

A local code graph: it parses a project with Tree-sitter, stores symbols and cross-file links in a database, and updates them as files change. Agent IDEs query it over MCP, so they can find callers and dependencies without opening whole files.

An MCP server that gives a coding agent a real Chrome to drive: click, type, navigate, read console and network logs, take screenshots and record performance traces. It runs on Puppeteer and the DevTools protocol and has a slim mode for lighter use.

A CLI and web catalog for Claude Code. You browse agents, commands, MCP configs, hooks and skills, then install them into a project with one npx command. It also includes session analytics and a health check.

An MCP server that lets Claude Desktop read and write files, run terminal commands, manage running processes, and handle Excel, PDF and DOCX files. It keeps an audit log of the commands it runs.

A local command-line tool that reads your Claude Code session logs and flags eight kinds of token waste, such as huge bash output, repeated file reads and retry storms. It puts a rough dollar figure on each and suggests a one-line fix, and it can open a small local dashboard.

A personal AI setup that installs into .claude as a bundle of skills. Memory is split by purpose (work, knowledge, learning, relationships), a versioned seven-phase problem-solving loop runs underneath, and one background daemon handles voice, hooks and cron.

A collection of DESIGN.md files, plain Markdown descriptions of the visual system of dozens of real websites: colors, type, spacing and button rules. Drop one into a project and an AI tool gets the look in words.

A runtime that runs AI agents inside an isolated sandbox. You declare which files, system calls and network hosts the agent may touch. API keys go only into requests bound for approved hosts, and any change to the policy waits for a human to review it.

A Python library that records each agent run, including LLM calls, tool calls and cost per session, and draws it as a replayable graph. It needs a few decorators or one init line and hooks into CrewAI, LangGraph, LangChain and LlamaIndex.

A single static C binary that indexes a codebase with tree-sitter across 158 languages and keeps a knowledge graph on disk. It exposes 14 MCP tools for search, call-chain tracing, impact checks and dead-code finds, and it configures several coding agents during install.

An MCP server that searches a catalog of community skills and MCP servers, then loads the best match into the current session. It can merge the top five matches into a single playbook.

A local proxy that lets Claude Code and Codex call other model providers, including free tiers and local runtimes such as Ollama and llama.cpp. You choose which model handles Opus, Sonnet and Haiku requests, and a small admin page holds the keys and routing.

A Claude Code skill that changes how replies are written: the next action comes first, multi-step work gets numbered, and each reply ends on one concrete step with no filler or sign-off. A flag file can switch it on for every session.

A desktop app built around Claude Code. You browse projects and past sessions and resume them, make custom agents, look at usage charts, and manage MCP servers and CLAUDE.md files from one window. It has to be built from source for now, with no installer published.

A desktop app (Tauri) that gives Claude Code a visual front end: browse sessions and projects, make custom agents, see token cost by model and project, edit CLAUDE.md, and manage MCP servers. Sessions can be checkpointed and forked.

A desktop app that runs several Claude Code or Codex sessions side by side, each in its own git worktree with its own terminal, diff view and live preview of the dev server. You can comment on agent patches, open pull requests, and set agents to run on a schedule.

An MCP server that drives an Android phone from plain-language instructions. It reads the screen, taps and types, checks device state before each step, and keeps logs and screenshots of each run. It connects to Claude Code and other MCP hosts.

Two markdown skill packs for AI coding tools. One walks the model through a landing page, from intake questions to section order and copy. The other teaches it to work in Figma over MCP using tokens, text styles and auto layout. The visual values are meant to be swapped for your own brand.

A multi-phase security audit skill for coding agents. It maps the architecture, hunts for issues unit by unit, and has a fresh agent try to disprove each finding before it is kept. Results are written as schema-checked findings.json, and target code runs only in a no-network sandbox.

A reference repo that walks through all thirteen Claude Code hook events with working Python scripts. It logs every event as JSON, blocks a few dangerous shell commands, and can read status aloud through text-to-speech.

A workflow you run inside a coding agent that grades how a session went across five parts, from how the task was understood to whether the changes were checked. It lists the gaps it finds and drafts a scoped fix for each one.

A set of files placed in a repo, plus a Rust CLI, that makes a project easier for coding agents to work in. It adds an AGENTS.md, an architecture doc, a guide for classifying new work, and story packets with validation expectations. A local runner executes each story in its own workspace and saves a summary and result.

A research framework that runs a coding agent through repeated rounds: it reads the execution traces, distils them into reports, then proposes evidence-backed edits to the agent's prompts, tools and skills, and checks them in the next round.

A command-line checker that grades agent skill folders on format, quality and security with no API key. The heavier checks compare skills against each other and run an agent with and without the skill, which needs a model key and a sandbox.

A loop that runs an agent on a benchmark, reads the failed traces, has a coding agent edit the agent's code, checks the change against a regression suite, then repeats. It ships setups for tau-bench, Terminal-Bench and BIRD-Interact.

A desktop canvas where a coding agent can draw architecture and flow diagrams, and link them back to the code they describe. It also has a structural diff view that shortens long functions into pseudocode and hides test and doc noise. It works on local checkouts and is MIT licensed.

A set of hooks and workflow rules for Claude Code. Each task becomes a git-backed ticket that runs in its own worktree, and hooks block risky moves such as editing main directly or skipping commit checks. It also keeps a short log of what agents learned.

A tool for Claude Code that reads your past session transcripts and proposes edits to CLAUDE.md and auto-memory. It re-runs a sample of old tasks, ranks the candidate edits by the agent's own preference instead of labels, and suggests the best one. The idea is worth adapting because it tunes notes from real past work rather than guesses.

A plugin that replaces Claude Code's file-reading, search, edit and shell tools with versions that return short views, such as the head and tail of a file with the middle cut. It also ships skills that nudge the agent toward cheaper habits.

A proxy you put in front of another MCP server. It rewrites the tool results into a tighter form that keeps every value, so the model reads fewer tokens per call. The savings figure in the README comes from the author's own measurements.

A single Python script that reads your Claude Code session logs and works out what each session cost. It reports prompt-cache hit rate and which tool calls and long outputs cost the most, and a diagnose mode suggests changes.

A Python CLI that installs a multi-step research pipeline into a Claude Code or Codex project. It fetches sources, stores each as a note in a searchable local vault, and checks citations before the report is written. A scholarly search client covers papers, trials and SEC filings.

A set of about 20 Claude skills for value-investing research. Four agents each take a different investor's view (Buffett, Munger, Duan Yongping, Li Lu), research a company in parallel, and then the outputs are merged where they disagree. Every skill uses one output format, so companies can be compared.

A Markdown archive, sorted by vendor, of system prompts collected from public AI chat products. Each model has its own file, and some entries link diffs between versions. Nothing in it runs.

A local indexer that builds call graphs across many languages with tree-sitter, reports what a change would break, and scores code health. It runs as an MCP server for Claude Code, Codex and Cursor and needs no API key.

A self-hosted platform that turns PDFs, scans and spreadsheets into structured JSON. You describe the fields in plain language in its Prompt Studio, then call an API or run batch jobs over a folder. It works with several LLM providers and vector databases.

A desktop app for macOS and Windows. You give it a goal, it routes the work to one of 16 built-in specialist agents or to one you define, and it tracks to-dos and recurring runs. It also connects to Gmail, Calendar, Sheets, Drive, Notion, Slack and Stripe.

Guidelines that steer coding agents toward newer Go idioms, such as max() and slices.Contains, limited to the Go version your go.mod declares. It ships as a plugin for several agents, backed by a small local CLI.

A Claude skill that pulls frames and a transcript out of a video so Claude can read it. It grabs one frame per scene change, denser at the opening seconds, and writes a report in a fixed layout.

A multi-agent research system that turns an open question into a grid of entities and attributes, has agents fill each cell with a sourced value, and writes an answer where every cell links back to its source. It has a terminal and a web interface and saves sessions for replay.

A CLI and MCP server that parses 17 languages into a symbol-level dependency graph, then answers what breaks if a symbol is removed or refactored. It also runs a local dependency-chain security scan and rates coupling.

A Python tool that checks web pages against WCAG 2.2, measures text contrast including text over images, and writes an accessibility statement in Spanish and English. It runs as a CLI or an MCP server and has no required dependencies.