#2
**mattpocock/skills** is a curated collection of AI coding agent "skills" — small, composable prompt-based workflows — built by Matt Pocock for real-world software engineering rather than casual "vibe coding." The project directly addresses four common failure modes when using AI coding agents: misalignment between intent and output, excessive verbosity, broken or untested code, and architectural decay. To fix misalignment, it introduces "grilling" skills (`/grill-me`, `/grill-with-docs`) that force the agent to ask detailed clarifying questions before writing any code. To combat verbosity, it promotes building a shared domain language via a `CONTEXT.md` file and Architecture Decision Records (ADRs), inspired by Domain-Driven Design principles. For code quality, it wraps test-driven development into a `/tdd` skill enforcing red-green-refactor loops, and provides a `/diagnosing-bugs` skill for structured debugging. To prevent architectural rot, `/improve-codebase-architecture` periodically scans the codebase and surfaces improvement opportunities as an HTML report. Skills are split into user-invoked (orchestration, e.g., `/implement`, `/wayfinder`, `/to-spec`, `/triage`) and model-invoked (reusable discipline, e.g., `/prototype`, `/code-review`). Installation is flexible: either via the `skills.sh` installer (`npx skills@latest add mattpocock/skills`), which copies editable files into your project, or as a managed Claude Code plugin that auto-updates. The project supports GitHub, Linear, and local file issue trackers. With ~60,000 newsletter subscribers and grounding in classic engineering literature, it is trending as a pragmatic, philosophy-driven alternative to heavier AI workflow frameworks like GSD, BMAD, and Spec-Kit, appealing to developers who want AI assistance without surrendering engineering control.
ToolsAgentscodingworkflow-automation
★ 189,984 total+12,197 this week
#9
Hallmark is a design skill/prompt layer for AI coding assistants (Claude Code, Cursor, and Codex) that aims to produce UI designs that don't look generically AI-generated. Created by Together AI and authored by Nutlope, it works by selecting a "macrostructure" for a given brief, applying one of twenty curated themes, and running 57 "slop-test" gates plus a pre-emit self-critique to avoid the default on-distribution patterns LLMs tend to produce. It exposes four verbs: a default build mode, an audit mode for scoring existing code, a redesign mode that rebuilds with a different fingerprint, and a study mode that extracts design DNA from screenshots or URLs. A newer "Custom" mode generates fully bespoke palettes, typography, and layouts from scratch when no catalog theme fits. Output is self-contained HTML + CSS. Installation is via `npx skills add nutlope/hallmark` and it integrates into Claude Code, Cursor, or Codex. The project is early-stage but notable for directly addressing the homogeneity problem in AI-generated UI, making it relevant to developers and designers seeking more distinctive, varied outputs from AI coding tools.
ToolsAppscodingworkflow-automation
★ 18,367 total+4,838 this week
#13
Ponytail is an AI agent skill/plugin that teaches coding agents to write dramatically less code by following a strict "laziness ladder" before generating any solution. The core idea is simple: before writing code, the agent checks whether the thing needs to exist at all (YAGNI), whether it already exists in the codebase, whether the standard library handles it, whether a native platform feature covers it, whether an installed dependency does it, whether it can be done in one line, and only then writes the minimum that works. The canonical example is replacing a full flatpickr date-picker component with a single `<input type="date">` HTML element. The project is benchmarked rigorously against real agentic workloads: a headless Claude Code session editing tiangolo's full-stack-fastapi-template (a FastAPI + React open-source repo), running twelve feature tickets with and without the skill, four runs each, using Claude Haiku 4.5. Results show ponytail reduces lines of code by ~54% on average (up to 94% on over-built tasks), cuts token usage by ~22%, lowers cost by ~20%, and speeds up sessions by ~27%, all while maintaining 100% safety — never dropping validation, error handling, security, or accessibility guards. Competing approaches like a terse "caveman" prose control or a "YAGNI + one-liners" prompt either fail on safety or don't cut every metric simultaneously. The project is notably mature in its multi-platform support, integrating with at least 20 agents including Claude Code, Codex, GitHub Copilot CLI, OpenCode, Gemini CLI, Antigravity CLI (Google's renamed Gemini CLI), Pi agent harness, Qoder, Hermes Agent, CodeWhale, and Swival. Installation is typically two plugin commands or a JSON config entry. The plugin injects its ruleset on every prompt turn via lifecycle hooks and registers slash commands like `/ponytail`, `/ponytail-review`, `/ponytail-audit`, `/ponytail-debt`, `/ponytail-gain`, and `/ponytail-help`. It is available on npm as `@dietrichgebert/ponytail` and is MIT-licensed. The project is trending on Trendshift both daily and weekly, suggesting rapid community uptake. Its honest, self-correcting benchmark methodology — acknowledging earlier inflated single-shot numbers and replacing them with a fairer agentic baseline — adds credibility. Ponytail is notable because it addresses a real and growing pain point: AI agents that over-
ToolsAgentsTrainingcodingworkflow-automation
★ 89,931 total+3,747 this week
#17
OpenCodeReview (OCR) is an AI-powered code review CLI tool open-sourced by Alibaba Group after two years of internal use serving tens of thousands of developers and identifying millions of defects. It reads Git diffs and sends changed files to a configurable LLM via an agent with tool-use capabilities, generating structured review comments with line-level precision. Its core design philosophy is a hybrid of deterministic engineering and agent-based dynamic decision-making: engineering logic enforces hard constraints like precise file selection, smart file bundling, and fine-grained rule matching, while the agent handles dynamic context retrieval and scenario-tuned prompting. Compared to general-purpose agents like Claude Code, OCR achieves significantly higher precision and F1 scores using only ~1/9 of the tokens, as validated on a benchmark of 50 open-source repos, 200 real PRs, and 1,505 annotated issues across 10 languages. It supports a "Delegation Mode" where coding agents like Claude Code, Codex, or Cursor perform the review using their own LLMs without requiring OCR API key configuration. Additional features include full-file scanning via `ocr scan`, CI/CD integrations (GitHub Actions, GitLab CI, Gerrit), MCP server support, OpenTelemetry observability, and session replay. Installable via npm, the project holds OpenSSF Silver badge status and is actively trending on Trendshift, making it notable for teams seeking precise, cost-efficient, production-validated AI code review.
ToolsAgentsEvalscodingsecurityworkflow-automation
★ 14,049 total+3,345 this week
#21
**Skills for Design Engineers** is a curated collection of AI agent "skills" created by Emil Kowalski, a design engineer with experience at Vercel and Linear, aimed at helping developers and designers build higher-quality user interfaces — particularly around animations and motion design. The core premise is that AI agents lack aesthetic taste and frequently make subtle but impactful mistakes, such as using the wrong easing curves or poor visual choices like solid borders instead of semi-transparent shadows. The skills act as structured rule sets that guide AI agents toward better decisions, effectively encoding years of domain expertise into reusable prompts or instructions. Installation is straightforward via `npx skills@latest add emilkowalski/skills`. The skill set covers animation review, animation improvement auditing, finding animation opportunities, animation vocabulary, Apple design principles translated for the web, and UI library selection. The project is notable for its timely positioning at the intersection of AI-assisted development and design craft, arguing that human expertise amplifies rather than gets replaced by AI. It is relatively early-stage but gaining traction, likely trending due to growing interest in "taste-driven" AI tooling and the broader agentic development ecosystem.
ToolsAppsworkflow-automation
★ 21,152 total+2,838 this week
#22
Agent Reach is a Python-based (3.10+) agent infrastructure layer that gives AI agents one-click internet access across 15+ major platforms including YouTube, Twitter/X, Reddit, Bilibili, Xiaohongshu (Little Red Book), LinkedIn, Facebook, Instagram, GitHub, V2EX, Xueqiu, and RSS feeds. Rather than being a tool itself, it acts as a capability routing layer that selects, installs, health-checks, and routes between the best available backend for each platform — abstracting away the pain of API paywalls, login requirements, anti-scraping blocks, and dirty HTML. Installation is triggered by a single natural-language prompt to any compatible agent (Claude Code, OpenClaw, Cursor, Windsurf, etc.), which then auto-installs CLI tools, system dependencies, MCP search integration via Exa, and registers a SKILL.md guide so agents autonomously know which upstream tool to invoke. The architecture uses an ordered primary+fallback backend list per channel (e.g., Bilibili switched from yt-dlp to bili-cli after B-site rate-limiting in June 2026), making platform changes transparent to users. A built-in `agent-reach doctor` command diagnoses which channels are live and which need fixing. Security is emphasized: cookies/tokens are stored locally with 600 permissions, never uploaded, with safe-mode and dry-run install options. The project is actively maintained by a solo developer, has reached Trendshift GitHub Trending #1 Repository of the Day, and is fully MIT-licensed and free, with optional ~$1/month proxy only needed for server deployments. It targets the rapidly growing agent-infrastructure niche, making it notably relevant as AI agents increasingly need reliable, maintained internet access pipelines.
ToolsMCPAgentsbrowser-useworkflow-automationsecurity
★ 61,066 total+2,725 this week
#23
jcode is a terminal-based AI coding harness (agent CLI) developed by 1jehuang, positioning itself as the most RAM-efficient and most intelligent harness available for AI-assisted software development. The project is cross-platform, supporting Linux, macOS, and Windows, and is installable via a single curl or PowerShell command. It is currently in active development, with versioned releases tracked on GitHub and a community Discord server for users and contributors.
The central value proposition of jcode is extreme resource efficiency, particularly in RAM consumption and startup speed, which the project argues is critical for scaling multi-session agentic workflows. The README presents detailed benchmark tables comparing jcode against a wide field of competing AI coding tools: pi, Codex CLI, OpenCode, GitHub Copilot CLI, Cursor Agent, Claude Code, and Antigravity CLI. In a single-session scenario with local embedding disabled, jcode consumes just 27.8 MB PSS — a baseline against which Claude Code uses 13.9× more RAM (386.6 MB) and OpenCode uses 13.4× more (371.5 MB). With local embedding enabled, jcode uses 167.1 MB for one session, still significantly less than most competitors. The efficiency advantage becomes dramatically more pronounced at scale: running 10 concurrent sessions, jcode (embedding off) uses only 117.0 MB, while OpenCode balloons to 3,237.2 MB (27.7× more) and Claude Code reaches 2,300.6 MB (19.7× more). The per-session memory scaling cost for jcode is approximately 9.9–10.4 MB per added session, compared to 318.4 MB for OpenCode and 212.7 MB for Claude Code.
Startup performance is equally emphasized. jcode achieves a time-to-first-frame of just 14.0 ms, making it 245.5× faster than Claude Code (3,436.9 ms) and 139.3× faster than Cursor Agent (1,949.7 ms). Time-to-first-input is 48.7 ms for jcode versus 3,512.8 ms for Claude Code. These benchmarks were measured across 10 interactive PTY launches on a Linux machine, with specific version numbers cited for reproducibility.
A standout architectural feature is jcode's agent memory system. Rather than relying on explicit tool calls or naive context stuffing, jcode embeds each conversation turn as a semantic vector and queries a memory graph using cosine similarity to surface relevant past information automatically. This creates a human-like passive recall mechanism. Memory extraction is triggered by semantic drift, a turn count threshold, or session end, and is handled by a dedicated memory side-agent. A separate ambient mode periodically consolidates memories, resolving conflicts and pruning stale entries. The system also supports explicit memory tools for active search and storage, as well as session search for traditional retrieval-augmented generation (RAG) over prior sessions.
The UI layer is also a notable differentiator. jcode features side panels that can display files in real time, serve as diff viewers, or accept direct agent writes. Both the chat and side panel support inline rendering of Mermaid diagrams, enabled by a custom Mermaid rendering library the author built specifically for this project, reportedly achieving 1,800× rendering improvement. Info widgets and careful attention to scrolling and alignment round out the terminal UI experience.
In terms of maturity, jcode appears to be a serious, actively maintained project in late pre-release or early release stage (version v0.9.1888-dev at time of benchmarking). It has a dedicated website (jcode.sh), documentation, a benchmarks page, and a contributing guide, suggesting it is moving toward a stable public release. The project is MIT-licensed and openly invites community participation.
From a trend analysis perspective, jcode is notable because it enters a rapidly crowding space of AI coding agents — competing directly with well-funded products like GitHub Copilot CLI, Cursor, and Claude Code — but differentiates on a dimension most competitors have neglected: systems-level efficiency. As agentic, multi-session AI workflows become standard in developer tooling, RAM and startup overhead become real operational costs. jcode's approach of treating resource efficiency as a first-class concern, combined with a sophisticated passive memory architecture and
ToolsAgentsAppscodinglocal-firstvector-database
★ 11,707 total+2,693 this week
#24
OfficeCLI is an open-source, self-described "world's first" Office suite purpose-built for AI agents, enabling any AI agent to create, read, modify, and analyze Word, Excel, and PowerPoint documents through a single binary with no Microsoft Office installation or external dependencies required. The project's central value proposition is collapsing what previously required 50+ lines of Python across multiple libraries into a single, expressive CLI command, dramatically lowering the barrier for AI agents to interact with Office file formats. It supports all three major Office formats — `.docx`, `.xlsx`, and `.pptx` — with full read, modify, and create capabilities across the board, making it a comprehensive solution rather than a format-specific tool.
A standout architectural feature is OfficeCLI's built-in HTML rendering engine, which converts Office documents to HTML or PNG with high fidelity. This closes the critical "render → look → fix" feedback loop for AI agents, effectively giving them visual awareness of the documents they are generating or editing. This is particularly significant for agentic workflows where an AI must iteratively refine a document's appearance without human intervention. The live preview server (`officecli watch`) reinforces this loop for human developers as well, refreshing a browser view in real time as commands are applied.
Integration with AI coding agents is a first-class concern. Running `officecli install` automatically detects and injects the OfficeCLI skill into popular AI coding environments including Claude Code, Cursor, Windsurf, and GitHub Copilot, requiring zero additional configuration. For AI agents themselves, a single `curl` command fetches a `SKILL.md` file that teaches the agent how to install the binary and use all commands autonomously. This design philosophy — agent-first, human-optional — is a notable differentiator from traditional Office automation libraries.
The feature set is remarkably deep for what presents as an early-stage open-source project. Word support includes full internationalization and RTL language support with per-script font slots, BCP-47 language tags, complex-script formatting, locale-aware page numbering for Hindi, Arabic, Thai, and CJK scripts, LaTeX equation input, Mermaid diagram rendering to native editable shapes or PNG, tracked changes with accept/reject actions, 22+ field types, content controls, OLE objects, and much more. Excel support covers 350+ built-in formula functions with auto-evaluation, dynamic array spilling, pivot tables with extensive configuration options including calculated fields and persistent filters, box-whisker and Pareto charts, sparklines, slicers, conditional formatting, data validation, CSV/TSV import, and phonetic/furigana cell guides. PowerPoint support includes rich shape manipulation, pattern fills, blur effects, hyperlink tooltips, slide-jump links, and header/footer controls.
The project ships as a single binary available via shell script, Homebrew (`brew install officecli`), npm (`npm install -g @officecli/officecli`), and PowerShell for Windows, making cross-platform deployment straightforward. It is licensed under Apache 2.0, signaling openness to commercial use and community contribution. A companion desktop GUI application, AionUi, is available for users who prefer natural language interaction over direct CLI usage, with OfficeCLI powering the document operations underneath.
The README is multilingual, available in English, Chinese, Japanese, and Korean, suggesting an intentional push toward a global developer and AI-agent ecosystem audience. The project includes a Discord community and a dedicated website at officecli.ai. All showcase documents — presentations, Word reports, and Excel dashboards — were generated entirely by AI agents using OfficeCLI without templates or manual editing, serving as a compelling demonstration of the tool's agentic capabilities.
From a trend analysis perspective, OfficeCLI sits at the intersection of two major currents: the rapid growth of agentic AI systems that need to interact with real-world productivity tools, and the demand for lightweight, dependency-free developer utilities. Its agent-first design, deep Office format support, visual feedback loop, and seamless integration with leading AI coding environments position it as a potentially high-momentum project as autonomous agent workflows become mainstream. The bold "world's first" claim and the breadth of features packed into an early release suggest an ambitious team moving quickly to establish category leadership.
ToolsAgentsAppsworkflow-automationcodingmultimodal
★ 22,440 total+2,682 this week
#25
Taste Skill is an open-source "Anti-Slop Frontend Framework for AI Agents" — a collection of portable Agent Skills designed to upgrade AI-generated user interfaces beyond generic, boilerplate-looking outputs. Rather than accepting mediocre layouts and typography from coding agents, Taste Skill provides structured SKILL.md files that instruct agents like Codex, Cursor, and Claude Code to apply stronger layout variance, refined typography, intentional motion, and deliberate spacing. The framework is organized into two categories: implementation skills that output production code, and image-generation skills that produce design reference boards for web, mobile, and brand identity work. The flagship skill, `design-taste-frontend`, is currently at v2 (experimental) — a substantial rewrite featuring brief inference, design-system mapping, configurable dials for DESIGN_VARIANCE, MOTION_INTENSITY, and VISUAL_DENSITY (each rated 1–10), canonical GSAP animation skeletons, a hard em-dash ban, and a strict pre-flight check. Additional specialized skills cover brutalist UI, minimalist/editorial UI, soft premium aesthetics, redesign auditing of existing codebases, full-output enforcement, and Google Stitch compatibility. Image-generation skills pair with ChatGPT Images or similar generators to produce comps that are then handed off to coding agents. Installation is handled via the `npx skills add` CLI from the vercel-labs/agent-skills ecosystem, making adoption straightforward. The project has notable corporate sponsorship from Novamira, IMG.LY, Vercel, Sent.dm, and Emil Kowalski's animations.dev, signaling real community traction. It is MIT-licensed and actively iterating, positioning itself at the intersection of AI coding agents and high-quality frontend design — a timely and trending niche as AI-generated UI quality becomes a growing concern.
ToolsAppscodingworkflow-automationsynthetic-data
★ 67,989 total+2,675 this week
#31
Caveman is a plugin/skill for AI coding agents that compresses their output into terse, caveman-style speech while preserving 100% of technical content — code, commands, and error messages remain byte-for-byte exact. The core value proposition is a claimed average 65% reduction in output tokens across benchmarks, demonstrated through before/after comparisons showing verbose agent replies stripped down to minimal, information-dense equivalents. It works as a one-command install across 30+ agents including Claude Code, Codex, Gemini CLI, Cursor, Windsurf, Cline, and GitHub Copilot, requiring Node ≥18 and taking roughly 30 seconds to set up. Users can choose from five compression levels — lite, full (default), ultra, and wenyan (classical Chinese for maximum token density) — switchable mid-session via `/caveman <level>`. Beyond basic compression, the toolkit includes commands for conventional commit messages, one-line PR reviews, session token stats with USD cost tracking, memory-file compression (cutting ~46% of input tokens permanently), an MCP middleware wrapper called caveman-shrink, and multi-agent subagents called cavecrew. The project is notably honest about its limitations: the skill itself adds ~1–1.5k input tokens per turn, whole-session savings are smaller than the headline output number, and terse workloads can go net-negative. It cites a March 2026 arXiv paper suggesting brevity constraints actually improved model accuracy by ~26 points on some benchmarks, lending academic credibility to the approach. Caveman sits within a broader ecosystem of five related repos — caveman-code (full agent), cavemem (memory compression), cavekit (spec-driven build loop), and cavegemma (a fine-tuned Gemma model with compression baked into weights) — plus a sibling skills registry. The project appears early-stage but actively maintained, with reproducible benchmarks, multilingual support, and integrations including OpenClaw self-hosted gateway, signaling genuine engineering depth behind the playful branding.
ToolsMCPServingcodingworkflow-automationsynthetic-data
★ 93,262 total+2,360 this week
#33
**CAD Skills** (`earthtojake/text-to-cad`) is an open-source Python library (Python 3.11+, MIT license) that provides a modular collection of agent-callable skills for generating, inspecting, sourcing, slicing, and handing off CAD and robot-description artifacts using plain-language or image prompts. The core CAD skill produces geometry in STEP format with additional export options including STL, 3MF, and GLB — making it directly relevant to 3MF-based workflows for 3D printing and fabrication pipelines. Complementary skills cover URDF/SRDF/SDF robot description files for simulation and MoveIt2 planning, DXF 2D drawings, G-code slicing via real slicer CLIs, off-the-shelf STEP part sourcing via step.parts, SendCutSend preflight checks, Bambu Labs printer integration, and an experimental implicit CAD skill using GLSL signed-distance fields. Installation is handled through a Skills CLI (`npx skills install`), with native plugin support for OpenAI Codex and Anthropic Claude Code. The repo includes a structured benchmark suite of ten progressively complex CAD targets — from calibration blocks and flanges to planetary gear stages and spiral staircases — stored via Git LFS. The project is actively developed, community-driven (Discord), and notable for bridging LLM-based agents with real fabrication toolchains end-to-end, spanning design, simulation, slicing, and physical printing in a single skill ecosystem.
ToolsAppsMCPmultimodalcodingworkflow-automation
★ 10,626 total+2,218 this week
#34
Headroom is an open-source context compression layer designed specifically for AI agents and LLM-powered applications. Its core purpose is to dramatically reduce the number of tokens consumed by agents when processing tool outputs, logs, RAG chunks, files, and conversation history — before any of that content ever reaches the language model. The project claims 60–95% token reduction for JSON data and 15–20% reduction for coding agent workflows, while preserving answer accuracy as validated on standard benchmarks including GSM8K, TruthfulQA, SQuAD v2, and BFCL. On real agent workloads, demonstrated savings range from 47% on codebase exploration up to 92% on code search and SRE incident debugging tasks.
Headroom offers four primary integration modes. First, a Python and TypeScript library allowing inline `compress(messages)` calls. Second, a drop-in proxy (`headroom proxy --port 8787`) requiring zero code changes in any language. Third, an agent-wrap CLI command that wraps popular coding agents like Claude Code, Codex, Cursor, Grok, Copilot, Aider, Cline, Continue, Goose, OpenHands, and others in a single command, with a corresponding `unwrap` to undo. Fourth, an MCP server exposing `headroom_compress`, `headroom_retrieve`, and `headroom_stats` tools for any MCP-compatible client.
The internal architecture routes content through a ContentRouter that detects content type and selects the appropriate compressor: SmartCrusher for JSON, CodeCompressor for AST-based code, and Kompress-v2-base (a custom Hugging Face model) for prose and general text. A CacheAligner stabilizes prompt prefixes to maximize provider-side KV cache hit rates. The system also implements CCR (Compressed Context with Retrieval), a reversible compression scheme that caches original content locally so the LLM can call `headroom_retrieve` on demand — meaning compression is lossless in practice, not just approximate.
Beyond input compression, Headroom also targets output token reduction, which is particularly significant since output tokens on Opus-class models cost roughly five times more than input tokens. It does this through verbosity steering (appending terse-response instructions to system prompts without breaking prompt caches) and effort routing (dialing down model thinking effort for routine tool-result turns while preserving full effort for new questions or errors). These features apply to both Anthropic and OpenAI-compatible endpoints and are toggled via `HEADROOM_OUTPUT_SHAPER=1`. A `headroom learn --verbosity` command can automatically infer preferred terseness levels from past sessions.
Cross-agent memory is another notable feature: a shared store that works across Claude, Codex, Gemini, and Grok with automatic deduplication. The `headroom learn` command mines failed sessions and writes corrections to agent-specific memory files such as `CLAUDE.local.md`, `AGENTS.md`, `GEMINI.md`, or `GROK.md`. The project is local-first by design — all compression and memory operations run on the user's machine, with no data leaving to external servers.
The project is available on PyPI as `headroom-ai` and on npm for the TypeScript SDK. It requires Python 3.10+ and supports modular extras including proxy, MCP, ML, code, memory, vector (HNSW), image, LangChain, Agno, Strands, and evaluation tooling. A `headroom doctor` command provides health checks, and a live dashboard shows real-time savings. The project is already trending on Trendshift and carries an Apache 2.0 license. Its combination of aggressive, content-aware, revers
ToolsRetrievalMCPlocal-firstsynthetic-datavector-database
★ 62,638 total+2,216 this week
#35
The `andrej-karpathy-skills` repo provides a single `CLAUDE.md` configuration file designed to improve the behavior of Claude Code (Anthropic's AI coding assistant) by encoding four coding principles inspired by Andrej Karpathy's public observations about LLM coding pitfalls. The four principles are: **Think Before Coding** (surface assumptions and ambiguities rather than silently guessing), **Simplicity First** (write minimum viable code, avoid overengineering), **Surgical Changes** (only touch code directly related to the task), and **Goal-Driven Execution** (define verifiable success criteria so the LLM can loop autonomously). Installation is offered either as a Claude Code plugin (available via a marketplace command) or as a per-project `CLAUDE.md` file via curl. The repo also includes Cursor IDE integration through a committed project rule file. It is notably early-stage but practically useful, riding the wave of interest in prompt engineering and AI coding agent configuration. Its trending appeal stems from Karpathy's influential status in the AI community and the growing demand for structured guidelines to make LLM coding agents more reliable and disciplined.
ToolsAgentscodingworkflow-automation
★ 196,619 total+2,179 this week
#41NEWPartial week
**video-shotcraft** is an AI agent skill that transforms Claude Code or Codex into a full motion-design studio for crafting cinematic product promo videos. It provides 104 shot recipe cards across 10 functional categories, 161 motion-style previews, and a complete production methodology covering storyboarding, visual direction, beat-synced editing, and film-grade sound design. The toolkit is powered by Remotion (a React-based video framework) and includes a ready-to-run template called **Ink Press** — a 36.2-second, 1920×1080, 30fps product promo with 2.5D camera moves, transitions, and a pinned SFX pass. Agents can install it via a single CLI command or repo link, then generate videos by referencing named shot cards or the Gallery. The library also ships 149 SFX organized into 16 scene/material categories and 5 BGM options. Motion techniques were reverse-engineered from top SaaS product films (ClickUp, Notion, Figma, etc.) and re-implemented from scratch. The project is actively maintained with recent updates including a restructured audio library, GitHub Pages Gallery auto-deployment, and expanded SFX coverage. Its tight integration with AI coding agents and production-ready scaffolding make it a notable emerging tool in the agentic video-generation space.
ToolsAppsDatavideomultimodalcoding
★ 1,975 total+1,791 this week
#48
HyperFrames is an open-source framework developed by HeyGen that converts HTML, CSS, media assets, and seekable animations into deterministic MP4 videos. Its core value proposition is elegantly simple: write HTML, render video. The framework is explicitly designed to be used by AI coding agents, making it highly relevant to the current wave of agentic development tooling. Rather than requiring developers to learn a proprietary video DSL or GUI timeline editor, HyperFrames lets agents and developers describe video compositions using familiar web technologies — HTML and CSS — and then renders them frame-accurately into MP4 output.
The framework ships with a rich skills system comprising 19 modular agent skills that can be installed via the `npx skills add` command and are compatible with major AI coding agents including Claude Code, Cursor, Gemini CLI, and OpenAI Codex. These skills teach agents a full production loop: planning the video, writing valid HTML, wiring seekable animations, adding media, linting, previewing, and rendering. The router skill `/hyperframes` acts as the central intent layer, dispatching to specialized creation workflows based on the type of video requested.
The creation workflow catalog is impressively broad, covering product launch videos, faceless explainers, PR-to-video changelogs, embedded captions, talking-head recuts, motion graphics, music-to-video beat-synced content, slideshows, general freeform video, and even migration from Remotion (React-based) compositions. This breadth signals an ambition to be a general-purpose programmatic video rendering engine rather than a niche tool. Each workflow is a discrete skill that agents load on demand, keeping installs lean and modular.
Domain skills handle atomic capabilities: `/hyperframes-core` defines the composition contract using `data-*` timing attributes; `/hyperframes-animation` covers animation runtimes including GSAP, Lottie, Three.js, Anime.js, CSS, WAAPI, and TypeGPU; `/hyperframes-keyframes` handles seek-safe keyframe authoring; `/hyperframes-creative` covers design direction, palettes, typography, and audio-reactive visuals; `/media-use` manages the full media pipeline including TTS, music generation, image generation, transcription, captioning, and background removal; `/hyperframes-cli` covers the full developer loop from init through cloud and AWS Lambda rendering; and `/hyperframes-registry` manages installable blocks and components.
The project is distributed as an npm package, requires Node.js 22 or higher, is licensed under Apache 2.0, and has an active Discord community. It also supports a Codex plugin archive format for upload to OpenAI's Codex environment. The existence of hosted cloud rendering via HeyGen's infrastructure and AWS Lambda rendering support suggests a path toward production-scale usage beyond local development. HyperFrames is notable from a trend analysis perspective because it sits at the precise intersection of two major 2024–2025 trends: agentic AI coding workflows and programmatic video generation. By making video creation a first-class skill for AI agents using web-standard technologies, it lowers the barrier for
ToolsAppsMCPvideocodingworkflow-automation
★ 37,884 total+1,580 this week
#49
**nature-skills** is an open-source, reusable scientific research skill library targeting global AI researchers, with a particular focus on enabling agentic, AI-driven academic workflows. Created by Yuan Yizhe (袁一哲), the project curates a growing collection of 18 modular skills—each organized around a `SKILL.md` file—that cover common research tasks such as bilingual paper reading, literature-to-PPT conversion, academic writing and polishing in Nature style, reviewer report simulation, peer-review response drafting, citation analysis, and research figure generation. The philosophy behind the project is that virtually any practical research tool can be abstracted into a standardized, reusable workflow that an AI agent can learn and execute autonomously, without requiring users to deeply study the underlying design. A notable design principle is that the skills are machine-readable: users can simply point Codex or another agent at the GitHub repository URL and have it automatically learn the skill design philosophy and generate or adapt new skills on demand. The project supports installation across multiple AI coding agents—Claude Code, OpenAI Codex, OpenClaw, OpenCode, and Hermes—via an `npx skills` CLI, shell scripts, or manual cloning, with optional auto-update hooks that silently sync skills in the background at session start. Skills are organized into self-contained directories preserving references, static assets, manifests, and scripts, with a shared support package (`nature-shared`) used by several skills. Optional Python dependencies support specialized skills like patent conversion (`nature-paper-to-patent`) and academic search via MCP server (`nature-academic-search`), with integrations for PubMed, Scopus, ScienceDirect, and China's CNIPA patent database. The founder notes that Google DeepMind's Science Skills project drew inspiration from nature-skills' citation system, scripting approach, and skill design philosophy—a point of pride signaling the project's international influence. Community engagement is maintained through Douyin (TikTok) video tutorials, a Knowledge Planet (知识星球) community, a WeChat research exchange group, and a commercial AI account top-up service. The project is actively maintained, bilingual (Chinese and English), Apache-2.0 licensed, and represents an early but maturing effort to formalize and democratize AI-assisted scientific research workflows for the broader academic community.
ToolsAgentsAppsworkflow-automationmultimodalsynthetic-data
★ 31,371 total+1,540 this week
#50
**Awesome DESIGN.md** is a curated awesome-list repository maintained by VoltAgent that collects ready-to-use `DESIGN.md` files extracted and analyzed from real, well-known websites across dozens of industries. The core concept originates from Google Stitch, which introduced `DESIGN.md` as a plain-text, markdown-formatted design system document that AI coding agents can read to generate visually consistent UI — no Figma exports, no JSON schemas, no special tooling required. Developers simply drop a `DESIGN.md` file into their project root, tell their AI agent to "build me a page that looks like this," and receive high-quality UI output that respects the design language, tokens, patterns, and rules encoded in the file. The repository currently hosts 73 such files, spanning categories including AI & LLM platforms, developer tools & IDEs, backend/database/DevOps, productivity & SaaS, design & creative tools, fintech & crypto, e-commerce & retail, media & consumer tech, and automotive. Each entry links to a hosted DESIGN.md and includes a brief design-language descriptor (e.g., Stripe's "signature purple gradients, weight-300 elegance" or Nike's "monochrome UI, massive uppercase Futura, full-bleed photography"). Users can also request custom DESIGN.md files for specific websites via getdesign.md. The repo is ranked approximately #150 globally on GitHub and carries the official Awesome badge, signaling community validation. It targets developers, designers, and "vibecoders" working with AI coding agents and web builders. Its notable ecosystem tool, LaunchKit, is promoted alongside a sponsorship program. The project is actively maintained and is trending due to the rapid rise of AI-assisted UI generation workflows, making it a practical, low-friction resource for anyone building with LLM-powered design agents.
ToolsAppsDatacodingworkflow-automationsynthetic-data
★ 104,740 total+1,536 this week
#51
RTK (Rust Token Killer) is a high-performance command-line proxy tool designed to dramatically reduce the volume of bash output consumed by AI coding agents, cutting up to 90% of shell command output before it reaches the LLM's context window. Built as a single Rust binary, RTK intercepts shell commands and applies four core compression strategies — smart filtering (removing noise, comments, boilerplate), grouping (aggregating similar items like files by directory or errors by type), truncation (keeping relevant context while cutting redundancy), and deduplication (collapsing repeated log lines with counts) — all with less than 10ms overhead. The project supports over 100 commands spanning files, Git, GitHub CLI, test runners, build and lint tools, package managers, AWS services, containers, infrastructure-as-code tools, and data utilities.
RTK integrates with a wide range of AI coding agents and tools including Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, Cursor, Windsurf, Cline, Roo Code, Kilo Code, Google Antigravity, Kimi AI, Pi, Hermes, and Factory Droid. Integration is achieved either through hook-based rewriting (automatically prepending `rtk` to bash tool calls) or through plugin APIs, meaning the agent receives compact output transparently without needing to call RTK explicitly. The tool is careful to clarify that its reported savings apply specifically to bash output tokens, which are only one contributor to total LLM input tokens, and that absolute token counts are approximated as bytes divided by four since RTK ships no tokenizer — making percentages reliable but raw numbers approximate.
Installation is straightforward via Homebrew (the recommended path), a curl-based quick installer for Linux and macOS, Cargo from the Git repository, or pre-built binaries for macOS (x86 and ARM), Linux (x86 musl and ARM), and Windows (MSVC). The project notes a name collision with an unrelated "Rust Type Kit" crate on crates.io and advises using the Git-based Cargo install to avoid confusion. RTK also ships a built-in analytics dashboard (`rtk gain`) with ASCII graph support to track cumulative token savings over time.
The project appears to be in active, mature development — currently at version 0.28.2 — with CI/CD via GitHub Actions security checks, multilingual README support across seven languages (English, French, Chinese, Japanese, Korean, Spanish, Portuguese), an active Discord community, and a dedicated website with troubleshooting guides and architecture documentation. Its notable positioning in the agentic coding trend is clear: as LLM-powered coding agents become mainstream, the cost and context-window efficiency of tool outputs becomes a real bottleneck, and RTK directly addresses this by acting as a transparent compression layer between the shell and the agent. This makes it a practically motivated, infrastructure-level tool for anyone running AI agents over codebases at scale
ToolsAgentsServingcodingworkflow-automationlocal-first
★ 73,372 total+1,467 this week
#52
DBX is a lightweight, open-source universal database management tool built with Rust, designed to support 70+ databases in a single binary weighing just 20 MB — with zero runtime dependencies like Java, Python, or bundled Chromium. It positions itself as a modern, cross-platform alternative to tools like DBeaver and TablePlus, running natively on macOS, Windows, and Linux, while also being deployable via Docker for team-based self-hosting and accessible through a web browser interface. The project's core value proposition is combining broad database compatibility, a built-in AI assistant, and Model Context Protocol (MCP) server support into one compact, fast tool.
The AI integration is a central feature: users can highlight a table, describe their intent in natural language, and receive SQL back directly within the editor — eliminating the need to copy-paste between tools. The AI assistant works with Claude, OpenAI, and local models via Ollama, and includes built-in safety checks that review AI-generated SQL before execution. This makes it particularly relevant to the current wave of AI-assisted development workflows.
DBX also functions as an MCP server, meaning AI coding agents such as Claude Code, Cursor, and Windsurf can query databases through DBX using connections already configured by the user — a single config that works across all compatible AI tools. This MCP capability is a strong differentiator and directly aligns DBX with the rapidly growing ecosystem of AI coding assistants that need structured data access.
The database coverage is remarkably broad, spanning relational databases (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, MariaDB, TiDB, CockroachDB, OceanBase, openGauss, GaussDB, KingBase, Redshift, DM, Doris, StarRocks, ClickHouse, DuckDB), NoSQL and search engines (MongoDB, Redis, Elasticsearch, Qdrant, Milvus, Weaviate, Manticore Search), time-series databases (TDengine, InfluxDB), and many more through JDBC-based agent profiles covering Snowflake, Hive, DB2, BigQuery, Cassandra, Neo4j, Databricks, SAP HANA, Teradata, Vertica, Firebird, and others. Cloudflare D1 and embedded databases like Access are also supported.
In terms of maturity and community traction, DBX is actively trending — it carries a Trendshift daily badge for Rust repositories, is featured on HelloGitHub and Product Hunt, and is listed on MCP Toplist. It has active community channels on Discord, QQ, and WeChat, and a Chinese-language README variant, suggesting strong adoption in both global and Chinese developer communities. The project is written in Rust, which contributes to its small binary size and performance characteristics. Overall, DBX is notable for its rare combination of extreme portability, AI-native design, MCP server capability, and unusually wide database support — making it a compelling tool at the intersection of database management and the AI-assisted development trend.
ToolsMCPAppslocal-firstvector-database
★ 11,793 total+1,432 this week
#53
AI Website Cloner Template is a reusable Next.js project template that enables AI coding agents to reverse-engineer any live website into a clean, modern codebase. Users point the tool at a target URL, run the `/clone-website` command, and the agent executes a multi-phase pipeline: reconnaissance (screenshots, design token extraction, interaction sweeps), foundation setup (fonts, colors, assets), component spec generation with exact computed CSS values, parallel component building via git worktrees, and final assembly with visual QA diffing against the original. The recommended agent is Claude Code with Opus 4.8, though 13 other agents are supported including Codex CLI, Cursor, Copilot, Gemini CLI, and Amazon Q. The tech stack centers on Next.js 16, React 19, TypeScript, shadcn/ui, Tailwind CSS v4, and Lucide React. Use cases include platform migration from WordPress/Webflow/Squarespace, recovering lost source code, and learning from production site implementations. The project is MIT-licensed, early-stage but actively maintained, and notable for its broad multi-agent compatibility and structured parallel-build approach to AI-driven site reconstruction.
ToolsAppsAgentscodingbrowser-useworkflow-automation
★ 30,298 total+1,424 this week
#55
**book-to-skill** is an open-source Python tool that converts any technical book, document folder, or collection of sources into a structured "agent skill" — a compact, on-demand knowledge base that AI coding assistants like GitHub Copilot CLI, Amp, and Claude Code can query directly during development sessions. The core problem it addresses is the "Discovery Loop Tax": when an AI agent reads a raw PDF to answer a question, it navigates back and forth through the document, consuming 24× to 51× more tokens than necessary. book-to-skill eliminates this by pre-distilling source material into a tightly organized skill directory containing a master `SKILL.md` (core mental models and chapter index, ~4,000 tokens), per-chapter files loaded on demand (~1,000 tokens each), a glossary, a patterns file, and a cheatsheet — all structured for minimal token overhead. The workflow is three steps: point the tool at a file, folder, or glob; it distills the content using Claude as the synthesis engine; and the resulting skill is written to the appropriate agent skills directory. Supported input formats are extensive: PDF, EPUB, DOCX, TXT, Markdown, reStructuredText, AsciiDoc, HTML, RTF, and MOBI/AZW/AZW3. For PDF extraction, the tool intelligently selects between fast prose extractors (pdftotext, pypdf, pdfminer.six) and the more thorough Docling for technical books with code blocks and tables. The project follows the open Agent Skills standard, meaning the same `SKILL.md` format works across GitHub Copilot CLI, Amp, and Claude Code without modification. Beyond books, it handles internal documentation, brand/design systems, research paper clusters, RFCs, and compliance specs — essentially any structured prose a developer re-reads frequently. Real-world conversion benchmarks show costs of roughly $1 per book on Claude Sonnet, with books like *Think Python 2* (244 pages, 119K tokens) and *Working Backwards* (371 pages, 175K tokens) serving as concrete examples. The tool includes a `--check` flag to audit which extractors are installed and what commands are needed to add missing ones. Design principles emphasize density over completeness, a practitioner voice ("Use X when Y"), front-loaded content, and on-demand chapter loading. The project achieved notable early traction, ranking **#10 Python Repository of the Day** and **#25 Repository of the Day** on Trendshift on May 23, 2026, signaling strong community interest. It is MIT-licensed, actively maintained with a changelog and architecture docs, and supports GitHub Sponsors. Its appeal on GitHub Trending likely stems from the convergence of AI coding assistants becoming mainstream and the practical, immediately usable solution it offers for grounding agents in real reference material without hallucination.
ToolsRetrievalDatacodingsynthetic-datalocal-first
★ 10,179 total+1,385 this week
#57
Humanizer is a portable agent skill written in plain Markdown that detects and removes telltale signs of AI-generated writing, rewriting text to sound more natural and authentically human. Because it is implemented as a single `SKILL.md` file, it runs in any agent harness that supports skill-style instructions, making it highly portable and easy to integrate. Installation is handled via the cross-agent Skills CLI (`npx skills add blader/humanizer`), with support for global or project-local installs, multi-harness deployment, and a dedicated Claude Code plugin path. The skill's detection logic is grounded in Wikipedia's "Signs of AI Writing" guide, maintained by WikiProject AI Cleanup, and covers 33 named patterns across five categories: content, language, style, communication, and filler/hedging. Patterns range from significance inflation, AI vocabulary, and em-dash overuse to chatbot artifacts, sycophantic tone, and manufactured staccato drama, each illustrated with concrete before/after examples. A standout feature is Voice Calibration: users can paste samples of their own writing so the skill matches their personal sentence rhythm and word choices rather than producing generic clean output. The skill enforces a strict no-fabrication rule — rewrites never invent facts, names, dates, or citations absent from the source text. It also runs a second audit pass to catch lingering AI-isms missed in the first rewrite. Currently at version 2.9.1, the project is actively maintained with a detailed changelog. Its combination of broad harness compatibility, empirically grounded pattern detection, and voice-matching capability makes it notable as a practical, production-ready tool for AI writing cleanup, which is a rapidly growing need as AI-generated content becomes ubiquitous.
ToolsAppsworkflow-automationsynthetic-data
★ 31,292 total+1,346 this week
#58Partial week
Archify is an agent skill that transforms a codebase or system description into polished, interactive, and shareable technical system maps directly within AI-powered coding environments. It integrates with Cursor, Claude Code, Codex CLI, and OpenCode, and is installed via a single `npx skills add tt-a1i/archify -g` command. The tool supports five distinct diagram types — Architecture, Workflow, Sequence, Data Flow, and Lifecycle — each suited to different technical communication needs, from runtime component maps to CI/CD pipelines and state machines. Four visual presets (Signal Flow, Blueprint, Classic, and others), dark/light themes, and optional finite motion give teams flexible presentation options. A core design principle is truthfulness: every interaction — node search, upstream/downstream reach tracing, route probing, role comparison, and guided story playback — is grounded strictly in authored relationships, never inventing topology or claiming runtime impact. Archify uses a typed JSON Intermediate Representation (IR) with deterministic, atomic validation gates covering schema, layout, HTML/SVG rendering, route integrity, and label clearance; a diagram only replaces the last known good artifact after all checks pass, and failures return machine-readable repair receipts with stable rule codes. The Architecture Delta feature enables before/after comparison of two validated snapshots, surfacing exactly what was added, removed, changed, moved, or rerouted — useful for pre-merge architecture reviews. Output is a single self-contained HTML file, with export options including PNG, SVG, WebM, and canonical 1200×630 share cards for READMEs and social posts. An optional desktop preview loop watches a JSON source file and reloads only verified revisions, keeping the last-good diagram visible during incomplete saves. Source-evidence mode links Architecture nodes to Git-verified file and line ranges pinned to a specific public commit, but only when explicitly requested. At version 2.12.0 under an MIT license, Archify is trending on Trendshift and is notable for combining agent-native workflow integration, strict validation discipline, and communication-first design — positioning it as a specialized alternative to generic diagramming tools or Mermaid themes for engineering teams.
ToolsAppsMCPcodingworkflow-automationmultimodal
★ 7,387 total+1,334 this week
#60
The `bradautomates/claude-video` repository introduces a plugin/skill called `/watch` that gives AI coding agents — primarily Claude — the ability to genuinely "watch" videos rather than merely guessing from titles or incomplete transcripts. The core problem it solves is that out-of-the-box, Claude and similar agents cannot process video content; pasting a YouTube link yields only surface-level inference. With `/watch`, users paste any URL (YouTube, Loom, TikTok, X, Instagram, and hundreds more via yt-dlp) or a local video file path, ask a question, and the tool fetches captions, downloads only what is needed, extracts frames, and produces a timestamped transcript — all handed to Claude so it can answer as if it actually watched the video.
The technical pipeline is well-documented: yt-dlp checks for native captions first (free and instant), ffmpeg extracts frames using one of three detail modes (`efficient` for keyframe-only fast extraction, `balanced` for scene-change detection, and `token-burner` for uncapped scene coverage), and audio is transcribed via Whisper (preferring Groq's `whisper-large-v3` for cost and speed, falling back to OpenAI's `whisper-1`). A smart frame deduplication system using mean absolute difference on 16×16 grayscale thumbnails drops near-identical frames before they consume token budget, which is a notable engineering consideration given that image tokens dominate cost. The tool includes a detailed frame budget table calibrated by video duration, and supports focused time-window analysis via `--start`/`--end` flags for denser per-second sampling.
Real-world use cases highlighted include analyzing competitor content hooks, diagnosing bugs from screen recordings, summarizing long videos, stripping hype from launch announcements, and converting playlists into searchable notes. Installation is zero-config for most users — dependencies install automatically on first run via Homebrew on macOS. The skill is compatible with Claude Code, Codex, Cursor, Copilot, Gemini CLI, and 50+ other agent hosts via the Agent Skills ecosystem, as well as claude.ai web via a downloadable `.skill` bundle. The project appears early-stage but polished, with thoughtful documentation covering performance benchmarks on a real 49-minute video, token cost estimates, and multiple install paths. Its trending appeal likely stems from the growing demand for multimodal AI agent capabilities and the practical gap it fills in video
ToolsAppsMCPmultimodalvideoaudio
★ 10,497 total+1,248 this week
#61
**Agent Skills** is a production-grade collection of 24 structured engineering workflows ("skills") designed to make AI coding agents behave like senior software engineers across every phase of the development lifecycle. Created by Addy Osmani, the project encodes the workflows, quality gates, and best practices that experienced engineers follow — packaging them so AI agents apply them consistently rather than improvising. The core philosophy is that good software development follows a disciplined sequence: Define → Plan → Build → Verify → Review → Ship, and each phase has dedicated skills and slash commands to activate the right behavior automatically.
The project exposes 8 slash commands (`/spec`, `/plan`, `/build`, `/test`, `/review`, `/webperf`, `/code-simplify`, `/ship`) that map directly to lifecycle phases. A standout feature is `/build auto`, which lets an agent generate a plan and implement every task in a single approved pass — removing human stepping between tasks while preserving test-driven commits and pausing on failures or risky steps. Skills also activate contextually: designing an API triggers `api-and-interface-design`, building UI triggers `frontend-ui-engineering`, and so on.
The 24 skills span a wide range of concerns: spec-driven development, planning and task breakdown, incremental implementation, test-driven development (Red-Green-Refactor, 80/15/5 test pyramid), context engineering, source-driven development (grounding decisions in official docs), doubt-driven development (adversarial in-flight review with optional cross-model escalation), frontend UI engineering (WCAG 2.1 AA accessibility), API and interface design (Hyrum's Law, One-Version Rule), browser testing with DevTools MCP, debugging and error recovery, code review (five-axis, ~100-line change sizing), code simplification (Chesterton's Fence, Rule of 500), and security hardening (OWASP). A meta-skill (`using-agent-skills`) helps route incoming work to the correct workflow.
Installation is broad and flexible. A one-command CLI (`npx skills add addyosmani/agent-skills`) installs all 24 skills into 70+ agents. Native integrations are documented for Claude Code (with marketplace plugin support), Cursor, Antigravity CLI, Gemini CLI, Windsurf, OpenCode, GitHub Copilot, Kiro IDE, Codex, and others. Skills are plain Markdown, making them compatible with any agent that accepts system prompts or instruction files. An Adoption Guide covers both greenfield and incremental rollout strategies for established codebases.
The project is trending on Trendshift and represents a notable shift in how AI-assisted development is structured — moving from ad hoc agent prompting toward repeatable, verifiable, senior-engineer-grade workflows that
ToolsAgentsAppscodingworkflow-automationsecurity
★ 80,532 total+1,193 this week
#63
Academic Research Skills (ARS) is a comprehensive suite of Claude Code skills designed to support academic researchers across the entire pipeline from initial research through to publication. Distributed under a CC BY-NC 4.0 license and currently at version v3.19.0, the project is installable in roughly 30 seconds via Claude Code CLI, VS Code, or JetBrains through a plugin marketplace, with alternative traditional symlink installation flows also documented. The central philosophy of the tool is "AI is your copilot, not the pilot" — it deliberately avoids full automation and instead handles the labor-intensive grunt work of research such as hunting down references, formatting citations, verifying data, and checking logical consistency, leaving the intellectual core (defining questions, choosing methods, interpreting data, and writing arguments) to the human researcher. Notably, ARS distinguishes itself from "humanizer" tools: rather than concealing AI usage, it aims to improve writing quality through features like Style Calibration (which learns a user's voice from past work) and Writing Quality Check (which catches machine-generated prose patterns).
The project's human-in-the-loop stance is heavily grounded in academic literature. It cites Lu et al. (2026, Nature) on "The AI Scientist," the first fully autonomous AI research system to pass blind peer review at an ICLR 2025 workshop, whose limitations enumerate failure modes (implementation bugs, hallucinated results, methodology fabrication, citation hallucinations, frame-lock, etc.) that ARS's integrity gates aim to avoid. Stages 2.5 and 4.5 run a 7-mode blocking checklist. ARS also draws on Zhao et al. (2026), who audited 111M references across 2.5M papers on arXiv, bioRxiv, SSRN, and PMC, conservatively estimating 146,932 hallucinated citations for 2025. In response, ARS added trust-chain frontmatter (v3.7.1), locator infrastructure with three-layer citation anchors (v3.7.3), and an opt-in claim audit pass (v3.8, via ARS_CLAIM_AUDIT=1) that fetches cited sources and judges whether claims are actually supported, gating output through a formatter terminal hard gate with five HIGH-WARN classes. Calibration ships as a 20-tuple gold set with FNR<0.15 and FPR<0.10 thresholds. Ren et al. (2026, a survey on self-improvements in agentic systems) provides further design rationale, noting that discovery agents cannot easily verify novelty, correctness, or reproducibility alone, and citing Lenat's EURISKO as a historical example of the value of human evaluation signals. Version 3.3 was inspired by PaperOrchestra (Song et al., 2026, Google), adopting Semantic Scholar API verification, anti-leakage protocol, VLM figure verification, and score trajectory tracking.
The architecture consists of four core skills. Deep Research is a 13-agent research team with Socratic guided mode, PRISMA systematic review, intent detection, dialogue health monitoring, optional cross-model data access, and Semantic Scholar verification. Academic Paper is a 12-agent writing system with Style Calibration, Writing Quality Check, LaTeX hardening, visualization, revision coaching, citation conversion, and figure verification. Academic Paper Reviewer is a 7-agent multi-perspective peer review system (Editor-in-Chief plus three dynamic reviewers and a Devil's Advocate) with 0–100 quality rubrics, concession threshold protocol, R&R traceability matrix, and read-only constraints. Academic Pipeline is a 10-stage orchestrator featuring adaptive checkpoints, claim verification, a Material Passport, optional repro_lock, cross-model integrity verification, and score trajectory tracking. Additional features include Data Access Level Metadata (raw/redacted/verified_only, enforced via a Python script and adapted from Anthropic's automated-w
ToolsAgentsAppsworkflow-automationmultimodalsynthetic-data
★ 39,659 total+1,147 this week
#66NEWPartial week
MEV-Arbitrage-Bot is a Solidity smart contract paired with a Python automation script designed to find and execute MEV (Maximal Extractable Value) arbitrage opportunities between Uniswap V2/V3 liquidity pools on Ethereum mainnet. The bot's core function, `executeArbitrage()`, scans for price discrepancies across pools and routers, executing profitable trades atomically in a single transaction. Supporting functions handle router/token whitelisting, swap limits, emergency pausing, approval revocation, and fund withdrawal, all restricted to the contract owner. Deployment is guided step-by-step through a browser-based tool called EtherLab, where users compile the Solidity contract at version 0.8.20, connect MetaMask or Phantom wallets, and launch Python automation without manual intervention. The automation loop uses `eth_estimateGas` dry-runs before committing real transactions, while a background scanner monitors live Uniswap swap events and logs activity in real time. The project targets beginners, recommending 0.5–1 ETH as starting capital and claiming ~$500/day returns — figures that are unverified and speculative. The repo appears early-stage and promotional in nature, notable primarily for combining on-chain MEV logic with a no-code-style deployment UI, making it accessible but potentially risky.
ToolsAppsworkflow-automationon-device
★ 1,520 total+1,085 this week
#68
The `coreyhaines31/marketingskills` repository is a structured collection of AI agent "skills" — markdown files that give AI coding agents specialized marketing knowledge and workflows — designed for technical marketers and founders who want to automate or accelerate marketing tasks using AI agents. The project covers an impressively broad surface area of modern digital marketing, including SEO auditing, conversion rate optimization (CRO), copywriting, paid advertising, email sequences, cold outreach, referral programs, churn prevention, pricing strategy, product launches, analytics, app store optimization, programmatic SEO, AI-optimized SEO, community marketing, influencer marketing, sales enablement, revenue operations, and more — totaling nearly 50 distinct skill modules. Each skill is a markdown file that an AI agent can load to apply domain-specific frameworks and best practices to a given task, making the system modular and extensible. The architecture is notably thoughtful: a central `product-marketing` skill acts as a shared foundation that every other skill reads first, ensuring all agents understand the product's positioning, audience, and context before executing any specialized task. Skills also cross-reference each other in meaningful clusters — for example, `copywriting` ↔ `cro` ↔ `ab-testing`, and `revops` ↔ `sales-enablement` ↔ `cold-email` — creating a coherent, interconnected knowledge graph rather than isolated prompts. The project is compatible with multiple AI agent platforms including Claude Code, OpenAI Codex, Cursor, and Windsurf, and adheres to the open Agent Skills specification at agentskills.io. It is built and maintained by Corey Haines, a marketer and founder who also runs Conversion Factory (a CRO and growth agency), the Swipe Files newsletter, an AI Marketing Training program, and Magister, an autonomous AI marketing agent that leverages these skills. The repository is open to contributions via pull requests and is actively maintained with an issue tracker. Its notable trendiness stems from the intersection of the booming AI coding agent ecosystem with practical, real-world marketing automation — essentially providing a plug-and-play marketing brain for any AI agent environment. For marketers unfamiliar with terminals or coding agents, a companion resource called Coding for Marketers is also referenced.
ToolsAgentsAppsworkflow-automationsynthetic-data
★ 41,848 total+1,071 this week
#69
Understand Anything is an open-source AI-powered developer tool built by Egonex AI that transforms any codebase, knowledge base, or documentation set into an interactive, explorable knowledge graph. Originally created by Lum1104, the project addresses a universal pain point for developers: onboarding into large, unfamiliar codebases. Rather than forcing engineers to read code blindly, it deploys a multi-agent pipeline to scan every file, function, class, and dependency, then constructs a structured knowledge graph saved locally as a JSON file. The resulting interactive dashboard lets users pan, zoom, search, and click through nodes, each annotated with plain-English summaries and relationship maps. Beyond structural visualization, the tool offers a domain view that maps code to real business processes, and a knowledge-base mode that ingests Karpathy-pattern LLM wikis, extracting wikilinks, categories, and implicit relationships via LLM agents to produce force-directed community graphs. Key features include guided architectural tours ordered by dependency, fuzzy and semantic search across the graph, diff impact analysis to preview ripple effects before committing, persona-adaptive UI that adjusts detail level for junior developers, PMs, or power users, automatic layer visualization color-coded by API/Service/Data/UI/Utility tiers, and in-context explanations of twelve programming language patterns. The tool supports localized output in English, Chinese (Simplified and Traditional), Japanese, Korean, and Russian. Installation is notably broad: it natively integrates with Claude Code as a plugin and supports one-line shell installation for over a dozen platforms including Codex, Gemini CLI, Cursor, VS Code with GitHub Copilot, Kiro, OpenCode, Vibe CLI, Cline, Trae, Hermes, KIMI CLI, Nanobot, Pi Agent, and Antigravity — the query-relevant platform, which uses the standard slash-command invocation pattern. Subsequent runs are incremental by default, re-analyzing only changed files to minimize token consumption, and a post-commit hook option enables automatic updates. The project is MIT-licensed, actively trending on Trendshift (repository #23482), and notable for its unusually wide platform compatibility, multilingual support, and its philosophy that AI should augment human understanding rather than replace developers.
ToolsRetrievalAppscodingvector-databaseworkflow-automation
★ 76,276 total+1,058 this week
#70
MengTo/Skills is a curated, open-source collection of 118 agent skills designed to help designers and developers build rich user interfaces, playable browser games, frontend systems, agent loops, automations, and reusable workflows using AI coding agents. Each skill is packaged as a portable, folder-based Markdown playbook (SKILL.md) that an agent can load and follow, with optional supporting files like REFERENCES.md, ARTICLE.md, demo HTML files, and helper scripts. The library spans six major categories: Codex workflows (17 skills), customer support (2), media (2), UI (1), game development (17), and web design (79), covering everything from converting screen recordings into detailed super-prompts to building isometric ARPGs in Three.js. The flagship workflow, Video to Super Prompt, turns a screen recording of a design or animation into a highly detailed prompt that can one-shot HTML generation. The project's philosophy treats prompts as versioned assets, favors explicit specs and visual references over vague descriptions, and structures skills as operating procedures with clear triggers, defaults, and guardrails. It is explicitly compatible with Codex, Claude Code, Cursor, Aura Build, and Lovable, making it broadly portable across the modern AI-agent stack. The repo is notably practical and production-oriented, targeting real design and development workflows rather than toy examples. Its breadth — spanning WebGL shaders, GSAP animations, SaaS billing support, game enemy AI, and editorial layout systems — makes it a comprehensive prompt-engineering and agent-orchestration resource. Its trending appeal likely stems from the surge of interest in AI coding agents and the growing need for structured, reusable prompt libraries that go beyond one-off chat interactions.
ToolsAppscodingworkflow-automationbrowser-use
★ 3,473 total+1,053 this week
#72
The `/last30days` project is an AI agent-led search engine and installable skill that aggregates real-time signals from over a dozen social platforms, prediction markets, and developer communities — then synthesizes them into a single ranked brief scored by actual human engagement rather than editorial curation. The core philosophy is that Reddit upvotes, X likes, YouTube views, TikTok engagement, and Polymarket odds backed by real money represent a more honest signal of what matters than any SEO-optimized editorial layer. The project explicitly positions itself against Google, ChatGPT, Gemini, and Claude, arguing that no single AI has native access to all these walled gardens simultaneously — but an agent with user-supplied API keys and browser sessions can bridge them all at once.
The skill installs in seconds via Claude Code's plugin marketplace or via `npx skills add` for Codex, Cursor, Copilot, Gemini CLI, and 50+ Agent Skills hosts. Zero configuration is required for Reddit, Hacker News, Polymarket, and GitHub; a first-run setup wizard unlocks X, YouTube, TikTok, arXiv, Techmeme, and Digg in about 30 seconds. The source table is extensive: Reddit (free, keyless, real upvote counts), X/Twitter, YouTube (full transcripts), TikTok, Instagram Reels, Hacker News, Polymarket, GitHub, Digg's AI 1000 feed, arXiv, Techmeme, LinkedIn, StockTwits, Threads, Pinterest, Xiaohongshu, Bluesky, Perplexity, and general web coverage. Community contributors continue adding niche sources like Truth Social.
The synthesis engine ranks results by social relevancy — a Reddit thread with 1,500 upvotes outweighs a blog post nobody read; a TikTok with 3.6M views outweighs a press release. Comments are now a default-on layer across sources, with rank-based diversity to prevent any single post from dominating. The tool supports multiple distinct use modes: person research before meetings, hiring signal analysis, topic discovery before a trend peaks, event coverage when something breaks, tool comparison with live GitHub star counts, travel intelligence, and fast learning from community-vetted prompting techniques.
The README is rich with concrete worked examples — researching Peter Steinberger before a meeting, tracking Kanye West's cultural moment across 23 Reddit threads and 86K upvotes, comparing AI agent tools like OpenClaw vs. Hermes vs. Paperclip with live star counts, and monitoring geopolitical events like an Iran-USA conflict scenario with Polymarket ceasefire odds. These examples make the value proposition tangible and demonstrate the breadth of the engine's intended use cases.
In terms of maturity, the project is actively developed and community-driven. As of v3.11.1 (July 2026), it has shipped 175 merged PRs across 15 releases since the v3.3 announcement in May, with 122 PRs from 52 community contributors. Notable recent additions include first-class OpenAI Codex plugin support with renderer-aware citations, free arXiv and Techmeme CLI integrations, a revived free Reddit path using RSS and shreddit scraping after the public JSON API died, and improved comment ranking across Instagram, YouTube, and crowd-voted Best Takes. The project was GitHub Trending #1 Repository of the Day and is tracked on Trendshift, signaling strong organic discovery momentum.
The project is notable for its agent-native architecture — it is not a standalone app but a composable skill that runs inside whatever AI coding or chat agent the user already has.
ToolsRetrievalAppsbrowser-useworkflow-automationmultimodal
★ 53,842 total+1,024 this week
#74NEWPartial week
**i-have-adhd** is a coding assistant plugin (skill) by ayghri that reformats AI responses to be ADHD-friendly — leading with the immediate action, numbering steps, capping lists at five items, and eliminating filler phrases like "Hope this helps!" No ADHD diagnosis is required to benefit from it. The project defines ten explicit communication rules: action-first output, numbered multi-step tasks, concrete next steps, suppressed tangents, per-turn state restatement, specific time estimates, visible wins, matter-of-fact error reporting, capped lists, and zero preamble or closers. It installs as a plugin for Claude Code or Codex with simple CLI commands and can be set to activate automatically on every session. Users can fork and customize the core `SKILL.md` file to tune the rules to their preferences. The project is early-stage but notable for its multilingual README (English, Simplified Chinese, Japanese, Korean), its clean before/after demonstration, and its timely intersection of AI tooling with neurodivergent accessibility. It is loosely inspired by the book *The Adult ADHD Tool Kit* by Ramsay and Rostain, adapted for LLM response behavior rather than personal productivity.
ToolsAppscoding
★ 10,719 total+1,009 this week
#76NEWPartial week
"No AI Slop" is an open-source writing skill/plugin by Peter Yang that detects and removes over 20 common AI-generated writing patterns without flattening the author's personal voice. It targets clichés like binary contrasts ("It's not X, it's Y"), throat-clearing openers, weasel attribution, fake-strong verbs, and dramatic fragmentation, while also enforcing fundamentals like active voice, leading with the point, and preferring concrete numbers. The tool integrates with Claude Code, OpenAI Codex, and ChatGPT as a plugin, and is invoked via a simple `/no-ai-slop` command to either edit a draft or detect AI patterns with quoted evidence. It includes a self-evaluation mechanism (`eval.md`) where the skill checks its own edits against pass/fail criteria. The project fits into the author's "25/50/25" writing workflow — human first draft, AI-assisted editing, human final pass. With 2,700+ GitHub stars, 611K impressions on X, and a public ChatGPT directory listing, it is clearly trending as AI-generated writing becomes increasingly prevalent and readers grow sensitive to its telltale patterns. Licensed under MIT.
ToolsAppscodingworkflow-automation
★ 2,811 total+984 this week
#82
Cangjie-Skill is a Chinese-language open-source project that distills methodologies from books, long videos, podcasts, and interviews into structured, callable AI agent skills. Rather than producing summaries or notes, it uses a proprietary seven-stage pipeline called **RIA-TV++** — combining Mortimer Adler's analytical reading method, five parallel extractors (frameworks, principles, cases, counter-examples, terminology), a rigorous triple-verification filter (cross-domain evidence, predictive power, uniqueness, with only 25–50% pass rate), structured RIA++ construction, Zettelkasten linking, pressure testing, and final delivery as installable skill packs for Claude Code or Cursor. The project has already generated 20+ skill packs spanning investment letters (Buffett, Duan Yongping), copywriting, influence psychology, classical Chinese texts (孙子兵法, 黄帝内经, 周易), and video courses (Andrew Ng's AI for Everyone). It sits within a broader ecosystem alongside nuwa-skill (distilling people) and darwin-skill (evolving skills). The project is actively growing with community contributors and external skill repos, making it notable as a practical agent-workflow infrastructure for knowledge reuse — particularly relevant to the rising trend of agentic skill composition and retrieval-augmented decision-making.
ToolsDataAgentssynthetic-dataworkflow-automation
★ 4,801 total+908 this week
#84
Floci is a free, open-source local AWS emulator designed for development, testing, and CI pipelines, allowing developers to run AWS-compatible services entirely on their local machine without requiring a cloud account, authentication tokens, or paid feature gates. The project's core philosophy is radical simplicity and zero friction: the fastest way to get started is a single `docker compose up` or the official CLI command `floci start`, after which standard AWS SDKs, CLI tools, Terraform, CDK, OpenTofu, and test suites can be pointed at `http://localhost:4566` with no workflow changes. Floci is named after floccus, the cirrocumulus cloud formation that resembles popcorn, and its tagline — "light, fluffy, and always free" — reflects both the name and its design goals around minimal resource usage.
A major motivation for Floci's existence is the sunset of LocalStack's community edition in March 2026, which began requiring auth tokens and froze security updates for free users. Floci positions itself as the no-strings-attached alternative, and the comparison table in the README is striking: Floci starts in approximately 24 milliseconds versus LocalStack's ~3.3 seconds, consumes only ~13 MiB of idle memory versus ~143 MiB, ships as a ~90 MB Docker image versus ~1.0 GB, and is licensed under MIT rather than a restricted license. The native binary weighs in at approximately 40 MB. These performance characteristics make it particularly well-suited for CI environments where startup time and resource consumption directly affect pipeline costs and speed.
Floci supports 69 AWS services spanning a remarkably broad range of categories. Core application services include S3, SQS, SNS, DynamoDB, Lambda, IAM, KMS, Secrets Manager, and SSM. Eventing and workflow services include EventBridge, EventBridge Pipes, EventBridge Scheduler, Step Functions, CloudWatch Logs, and CloudWatch Metrics. API and identity services cover API Gateway REST, API Gateway v2, AppSync, Cognito, ACM, and Route53. Container and compute services include ECS, EC2, EKS, ECR, CodeBuild, CodeDeploy, CodePipeline, AWS Batch, Auto Scaling, Elastic Beanstalk, and ELB v2. Data, analytics, and AI services include Athena (backed by a DuckDB sidecar called floci-duck), Glue, EMR, Firehose, OpenSearch, S3 Vectors, Textract, Transcribe, and Bedrock Runtime. Database and caching services include RDS (PostgreSQL, MySQL, MariaDB with IAM auth), Neptune (graph DB via TinkerPop Gremlin Server or Neo4j for openCypher), DocumentDB (MongoDB-compatible via real MongoDB containers), MemoryDB, and ElastiCache. Messaging services include SES, Kinesis, MSK (Kafka-compatible via Redpanda), Amazon MQ (RabbitMQ via real containers), Transfer Family, and IoT Core.
A key architectural differentiator is Floci's use of real Docker-backed execution for services where fidelity matters most. Lambda, RDS, Neptune, ElastiCache, MSK, ECS, EC2, EKS, OpenSearch, and CodeBuild all run as real Docker containers rather than shallow mocks, providing much higher compatibility with production behavior. The architecture is built on JAX-RS and Vert.x for HTTP routing, with services divided into stateless, stateful, and container-backed categories. Storage backends are configurable across in-memory, persistent, hybrid, and write-ahead log (WAL) modes depending on durability requirements.
The project supports SDK integration across all major AWS SDKs
ToolsAppsMCPlocal-firston-devicesecurity
★ 17,793 total+873 this week
#86
AI Berkshire is an investment research framework that systematically encodes the methodologies of four legendary value investors—Warren Buffett, Charlie Munger, Duan Yongping, and Li Lu—into a suite of 20 AI-powered skills compatible with both Claude Code and Codex. The core premise is that asking a generic AI for investment advice yields balanced but undecidable analysis, whereas AI Berkshire enforces structured, decision-ready outputs: explicit buy/pass/gray-zone verdicts, tiered price ranges for aggressive/moderate/conservative strategies, and multi-master perspective debates that surface genuine analytical tension. The framework is organized into three layers—a Skill layer with 20 named entry points, an Agent layer where team-mode skills spawn four parallel AI agents that independently research and challenge each other before a Team Lead synthesizes conclusions, and a Tool layer that enforces financial rigor through Python decimal arithmetic, multi-source cross-validation, and market-cap spot-checks. Anti-bias mechanisms are deeply embedded: an A/B/C information-richness rating prevents false confidence, a Munger-style inversion checklist forces failure-scenario thinking, eight hard red lines trigger automatic rejection regardless of valuation, and a "blank space" principle requires explicitly flagging unknowns rather than papering over them with speculation. The project claims real live-account returns of +69.29% in 2024 and +66.38% in 2025, outperforming the S&P 500 by roughly 46 and 50 percentage points respectively, with cumulative gains exceeding 1.46 million RMB across two years. Skills span deep single-company research, parallel earnings-team analysis, industry funnel screening, supply-chain bottleneck hunting, portfolio thesis tracking and drift detection, rapid news-pulse attribution, and even WeChat article generation via a three-agent author/editor/reader workflow. Installation is straightforward via git clone plus shell scripts for both Claude Code and Codex on macOS, Linux, and Windows. The project is actively trending on GitHub (Trendshift badge present), multilingual (Chinese, English, Japanese READMEs), and accompanied by a WeChat public account for curated research. Its combination of verifiable live performance, rigorous anti-hallucination tooling, and a one-person-equals-a-research-team value proposition makes it notably compelling for AI-augmented retail and professional investors alike.
ToolsAgentsAppsworkflow-automationsynthetic-data
★ 14,261 total+862 this week
#87
OpenWiki is a CLI tool built by LangChain AI that automatically writes and maintains structured wikis for codebases or personal knowledge management, designed specifically to serve as memory and context for AI agents. It operates in two distinct modes: **Code mode**, which generates and maintains repository documentation inside an `openwiki/` directory, and **Personal mode**, which builds a local "personal brain" wiki at `~/.openwiki/wiki/` by ingesting from a variety of configurable knowledge sources. The tool is installable globally via npm or pnpm and is written with Node.js, using `better-sqlite3` for checkpointing. OpenWiki's core value proposition is that it keeps documentation continuously up-to-date by integrating with CI/CD pipelines — supporting GitHub Actions, GitLab CI, and Bitbucket Pipelines — automatically opening pull or merge requests with documentation updates on a schedule. On each code run, it also maintains both `AGENTS.md` and `CLAUDE.md` at the repository root, injecting scoped blocks that instruct coding agents to reference the wiki for context, while leaving user-authored content untouched. A key architectural feature is its **local connector system**, which supports ingestion from Git repositories, Gmail, Notion, X/Twitter, Web Search (via Tavily), Hacker News, and Slack. Connectors use OAuth flows, MCP (Model Context Protocol) for some providers like Notion, and direct API access for others. Multiple instances of the same connector type can be configured independently, enabling fine-grained ingestion control. OpenWiki emits wikis in **Google Open Knowledge Format (OKF) v0.1**, a structured Markdown-with-YAML-frontmatter standard, ensuring interoperability and consistent relationship modeling between concept documents. The tool supports a wide range of LLM inference providers out of the box, including OpenAI, Anthropic, Google Gemini (both AI Studio and Vertex AI), AWS Bedrock, OpenRouter, Fireworks, Baseten, NVIDIA NIM, and Nebius Token Factory, with support for custom model IDs and alternative base URLs for proxied or self-hosted gateways. The default onboarding model is OpenAI's `gpt-5.6-terra`. Optional LangSmith integration enables tracing of OpenWiki runs to a dedicated project. Configuration and secrets are stored locally in `~/.openwiki/.env`, and on macOS, scheduled ingestion runs are installed as LaunchAgents. The project is trending on Trendshift, signaling strong community interest. Its notable combination of agent-first design, multi-source ingestion, CI automation, open knowledge format compliance, and broad LLM provider support makes it a compelling and practically useful tool in the rapidly growing space of AI agent infrastructure and automated documentation.
ToolsRetrievalDatalocal-firstworkflow-automationcoding
★ 13,318 total+817 this week
#90
`codex-keysmith` is a zero-runtime-dependency, single-file Python CLI (currently at source version v0.1.1) designed for versioned deployment of Codex instruction files into an existing Codex CLI configuration directory. Its core function is to deploy either a bundled or custom Markdown instruction file into a target `.codex` directory, conservatively updating the top-level `model_instructions_file` key in `config.toml` only when the value actually needs to change. A defining characteristic of the tool is its safety-first, preview-oriented design: by default it never writes anything, so normal deployment, uninstall, and interruption-recovery operations only produce a dry-run preview unless the user explicitly passes `--yes`. The dry-run output lists the target Markdown, the `config.toml` changes required, active and disabled hooks, exact-match legacy files, and full timestamped backup/archive paths, while clearly marking configs that need no backup. A key architectural feature is hook isolation: on a confirmed deployment, the tool backs up and moves the entire active `hooks.json` to `hooks.json.disabled`, pausing all hooks until they are explicitly restored via a restore command. Deployment and uninstall both publish a durable transaction journal before the first mutation, so interruptions such as `SIGKILL` can be inspected and recovered through an explicit `--recover` flow. The tool maintains a fingerprinted ownership manifest (`.codex-keysmith-manifest.json`) recording deployed MD/config values, actually isolated hooks, actually archived legacy files, backups, and prior manifest layers, enabling layered uninstall. The `--status` command performs a read-only structural health check reporting deployability, uninstall readiness, and structural health, and fails closed if durable journals or transaction residue exist; it hashes manifest-referenced backup recovery evidence but does not read or parse live hook contents. The project emphasizes an important global behavior boundary: a confirmed deployment alters the top-level `model_instructions_file`, so the instruction applies to every new Codex session loading that configuration rather than being a per-project sandbox. The tool explicitly does not patch Codex binaries, intercept network traffic, or store credentials. A prominent warning surrounds the bundled prompt: the v0.1.1 source embeds a byte-identical prompt (`examples/gpt-unrestricted.md`, SHA-256 `2c2c9f0e...`) that directs the model to answer without refusal framing, reinterprets reverse-shell/keygen/bypass requests as local fixtures, covers adult and consent-sensitive fiction plus chemistry/pharmacology/weapons guides, and gives its execution mode precedence over injected context—users are urged to inspect this prompt or supply their own via `--file`. Regarding maturity, the project treats provenance seriously: only checkouts bound to immutable signed/annotated tags with verified Release assets and matching `SHA256SUMS` count as official releases, while floating-branch checkouts are treated as candidates. A reproducible candidate build script (`scripts/build_release.py`) compares archive inputs byte-for-byte against verified commit blobs and rejects builds even when Git index tricks like `assume-unchanged` or `skip-worktree` hide worktree drift. Recommended runtime is Python 3.10–3.14 using only the standard library, with Python 3.9 retained for compatibility tests but treated as EOL. The verified Codex CLI version is `codex-cli 0.144.1`. Platform support centers on macOS and Linux, where users are directed to download signed v0.1.0 Release assets, verify them with `SHA256SUMS`, and avoid `curl | python`. Windows carries important caveats: v0.1.0 is declared "known-bad" for fresh deployment because it can trigger cascading `PermissionError
ToolsAppsSafetylocal-firstcodingsecurity
★ 1,786 total+746 this week
#91
Khazix Skills is a personal, open-source collection of six battle-tested AI agent skills built and daily-used by the author (KKKKhazix), all conforming to the AgentSkills open standard and compatible with 40+ agents including Claude Code, Codex, Cursor, and Kimi Code. The six skills cover: **leader** (transforms vague ideas into structured, long-horizon goal documents for autonomous AI execution); **storage-analyzer** (scans Mac/Windows disks and generates an interactive HTML report with color-coded cleanup recommendations); **aihot** (fetches daily AI news digests from aihot.virxact.com without API keys); **neat-freak** (post-task cleanup that syncs docs, CLAUDE.md/AGENTS.md, and agent memory to reflect actual project state); **hv-analysis** (dual-axis vertical/horizontal deep research producing 10,000–30,000 word PDF reports); and **khazix-writer** (replicates the author's personal WeChat public account writing style with strict anti-cliché rules). Each skill is a structured SKILL.md instruction set installable via a single natural-language command. The project is actively maintained, practically motivated, and notable for demonstrating real-world agentic workflow patterns across coding, research, writing, and system management domains.
ToolsAgentsAppscodingworkflow-automationsynthetic-data
★ 18,129 total+738 this week
#92
`kepano/obsidian-skills` is a collection of agent skills designed to extend AI coding agents with deep knowledge of Obsidian, the popular note-taking application. The project follows the Agent Skills specification (agentskills.io), making these skills portable across multiple compatible agents including Claude Code, Codex, and OpenCode. Installation is flexible, supporting a marketplace command, `npx skills`, or manual setup tailored to each agent's directory conventions. The five included skills cover Obsidian Flavored Markdown (wikilinks, embeds, callouts, properties), Obsidian Bases (views, filters, formulas), JSON Canvas file editing, Obsidian CLI interaction for plugin and theme development, and Defuddle-based web content extraction for token-efficient markdown conversion. The project is notably authored by kepano, the creator of Obsidian's Minimal theme and Defuddle, lending it credibility within the Obsidian ecosystem. Its cross-agent compatibility and alignment with an emerging open specification make it a notable early example of reusable, portable AI agent tooling — a trending pattern as agentic development workflows mature rapidly.
ToolsAgentsMCPcodingworkflow-automation
★ 43,403 total+731 this week
#98
The `vercel-labs/skills` repository is a CLI tool designed to power an open agent skills ecosystem, enabling developers to install, manage, and share reusable instruction sets — called "skills" — across a wide variety of AI coding agents. Skills are defined in `SKILL.md` files with YAML frontmatter specifying a name and description, and they extend an agent's capabilities with specialized tasks such as generating release notes from git history, creating pull requests following team conventions, or integrating with external tools like Linear and Notion. The CLI supports over 74 named coding agents, including prominent ones like Claude Code, Codex, Cursor, OpenCode, GitHub Copilot, Gemini CLI, Goose, Cline, Continue, and many more, making it a broadly interoperable tool across the AI developer tooling landscape.
Installation is straightforward via `npx skills add`, and the tool supports a rich variety of source formats: GitHub shorthand, full GitHub URLs, direct paths to specific skills within a repo, GitLab URLs, arbitrary git URLs, and local file paths. Skills can be installed at either project scope (committed alongside code and shared with a team) or global scope (available across all projects), and can be symlinked for a single source of truth or copied for environments where symlinks are unsupported. The CLI also supports non-interactive, CI/CD-friendly installation via flags like `--yes` and `--all`.
Beyond installation, the CLI offers a full suite of management commands: `skills list` to view installed skills, `skills find` for interactive or keyword-based discovery (with fzf-style search), `skills update` to pull the latest versions, `skills remove` to uninstall from specific agents or scopes, `skills use` to generate and pipe a skill prompt directly to an agent without permanently installing it, and `skills init` to scaffold a new SKILL.md template. The `skills use` command is particularly notable for its composability — it writes skill files to a temporary directory and either prints the generated prompt to stdout or launches a supported agent interactively.
The project appears to be in an active, early-but-functional state, originating from Vercel Labs, which signals strong institutional backing and a forward-looking focus on the rapidly growing AI coding agent space. Its breadth of agent support — spanning tools from Anthropic, OpenAI, Google, GitHub, JetBrains, and dozens of independent developers — positions it as a potential standard or hub for the emerging agent skills ecosystem. A companion discovery platform at skills.sh further enhances its ecosystem ambitions. Its appearance on GitHub Trending reflects strong community interest in tooling that bridges multiple AI agents under a unified, portable skill-sharing standard.
ToolsMCPAgentscodingworkflow-automation
★ 27,279 total+636 this week
#99
Cockpit Tools (jlcodes99/cockpit-tools) is a universal AI IDE account management desktop application designed to help users efficiently manage multiple accounts across a wide range of AI coding platforms simultaneously. The tool currently supports sixteen platforms: Antigravity IDE, Codex, GitHub Copilot, Windsurf, Kiro, Cursor, Grok CLI, CodeBuddy, CodeBuddy CN, Qoder, Trae, TRAE SOLO, Trae CN, TRAE SOLO CN, Zed, and ZCode. Its core value proposition centers on one-click account switching, multi-account multi-instance parallel execution, real-time quota monitoring, automated wakeup tasks to trigger quota resets, and plugin interoperability via a local WebSocket service. Each supported platform receives dedicated management features including OAuth authorization, token/JSON import, subscription plan recognition, quota visualization with progress bars, batch operations, and independent instance isolation with separate user directories and launch parameters. The application ships with a unified visual dashboard providing at-a-glance status across all sixteen platforms. It supports 18 interface languages and runs natively on macOS, Windows, and Linux, with installation via GitHub Releases or Homebrew on macOS. From a security standpoint, all account data is stored locally on the user's machine with no proprietary cloud backend; the WebSocket service listens only on localhost (127.0.0.1, port 19528) and can be disabled. Grok CLI credentials are stored as plaintext JSON protected by OS-level file permissions. The project appears actively developed and feature-rich, making it notable for power users who juggle multiple AI IDE subscriptions to maximize free-tier quotas across accounts — a trend increasingly common as AI coding tools proliferate. Sponsors include APIKEY.FUN and RoxyBrowser, suggesting commercial ecosystem interest around the tool.
ToolsAppsMCPlocal-firstcodingworkflow-automation
★ 14,480 total+619 this week
#100
Guizang PPT Skill is an AI-agent-native skill for generating single-file HTML horizontal-swipe presentations, illustrated slides, and multi-platform cover images, designed specifically for Claude Code and Codex agent environments. The project offers two distinct visual systems: Style A ("Electronic Magazine × E-Ink"), inspired by editorial publications like Monocle, suited for narrative and personal expression; and Style B ("Swiss International Style"), a strict grid-based system with 22 locked layouts, single high-saturation anchor colors, hairline rules, and no shadows or gradients, suited for factual, product, and methodology content. Installation is frictionless via a single `npx skills add` command or by instructing any shell-capable AI agent directly. Style B includes a script-based layout validator (`validate-swiss-deck.mjs`) and optional Playwright-based rendering checks for overflow, whitespace, and title spacing, reflecting a strong emphasis on quality control. The Codex integration enables AI-generated imagery via GPT-Image 2.0 and GPT-M 2.0, covering documentary photos, infographics, UI mockups, and screenshot redesigns, all bound to template aspect ratios. The project is actively sponsored by 360 Claw, Kimi Work, and Cola Skill, and backed by Zhenfund Token Grant, indicating real commercial traction. It is notable for treating HTML as a superior agent-editable format over traditional PPTX, enabling lightweight single-file delivery with no build step. Created by Chinese creator Guizang (歸藏) from real offline presentation experience, the repo is trending in the AI-agent tooling space due to its structured workflow, dual visual systems, and deep agent-platform integrations.
ToolsAppsAgentsmultimodalcodingvision
★ 22,451 total+612 this week
#101
Obsidian Mind is an open-source Obsidian vault template designed to give AI coding agents persistent, compounding memory across sessions. The core problem it addresses is that AI agents like Claude Code, Codex CLI, and Gemini CLI start every session with zero context — no awareness of ongoing projects, past decisions, team dynamics, or personal wins. Obsidian Mind solves this by turning an Obsidian vault into a structured, agent-readable knowledge base that persists and grows over time, so every new conversation builds on everything that came before.
The project's approach centers on a clean architectural separation: procedural hook scripts handle deterministic tasks like classification, validation, indexing, and lifecycle injection, while the AI agent handles judgment-heavy tasks like writing notes, filing them, linking them, and drafting briefs. Hooks written in TypeScript run via Node's `--experimental-strip-types` flag and are compatible across Claude Code, Codex CLI, and Gemini CLI using the same vault structure and commands. This multi-agent compatibility is a notable design goal — one vault works with all three major CLI agents without modification.
Memory is organized vault-first: all durable knowledge lives in `brain/` topic notes that are git-tracked, Obsidian-browsable, and interlinked. Claude Code's `MEMORY.md` file acts as an auto-loaded index pointing to vault locations rather than storing content itself, meaning memories survive machine changes and remain part of the knowledge graph. Folders group notes by purpose (work, people, decisions, performance), while Obsidian wiki-links group them by meaning, forming a graph the agent actively maintains and extends.
Sessions follow a designed lifecycle. A `SessionStart` hook automatically injects the user's North Star goals, active projects, recent git changes, open tasks, and a full vault file listing so the agent begins every session with rich context. Slash commands like `/om-standup`, `/om-dump`, `/om-incident-capture`, and `/om-wr` (wrap-up) drive structured workflows: morning kickoffs, brain dumps after meetings, incident response timelines, and end-of-day reviews that verify links, update indexes, and surface uncaptured wins via a `brag-spotter` subagent.
A standout optional feature is QMD semantic search integration. QMD runs three small models entirely locally — a 300MB embedding model, a 1.7B query-expansion model, and a 0.6B reranker — requiring no API key, no per-query cost, and functioning fully offline with GPU offload support for CUDA and Apple Silicon Metal. QMD is registered as a Model Context Protocol (MCP) server, exposing typed tools (`mcp__qmd__query`, `mcp__qmd__get`, `mcp__qmd__multi_get`) directly in the agent's tool menu alongside standard Read and Edit operations. This enables semantic recall — finding notes by meaning even when titles share no keywords with the query. Without QMD, the vault gracefully falls back to grep and the Obsidian CLI, so nothing breaks.
Installation is offered via ShardMind, a purpose-built package manager for Obsidian vault templates. ShardMind runs an interactive wizard that personalizes the vault with the user's name, organization, goals, and preferred agents, then initializes git and optionally bootstraps QMD. Critically, ShardMind is described as purely additive — deleting its sidecar files leaves a fully functional vault, and a default install is byte-equivalent to a plain `git clone`, preserving familiar developer UX.
The project supports four languages in its README (English, Japanese, Chinese, Korean), signals broad international reach. It requires Obsidian 1.12+, Node 22+ LTS, Git, and one of the three supported AI CLI agents. The vault is MIT-licensed and appears to be an early but thoughtfully engineered project, notable for its multi-agent compatibility, offline-first semantic search
ToolsRetrievalAgentslocal-firstvector-databasecoding
★ 4,008 total+600 this week
#102
Claude SEO is an open-source SEO analysis plugin built specifically for Claude Code, Anthropic's AI-powered coding and agentic assistant. Created by Daniel Agrici, the project transforms Claude Code into a comprehensive SEO auditing platform by introducing 25 sub-skills and 18 specialist agents that execute in parallel across a wide range of SEO domains. These domains include technical SEO, content quality assessment via E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness), Schema.org structured markup, AI search optimization (referred to as GEO — Generative Engine Optimization), local SEO, e-commerce SEO, and international SEO with hreflang support. Every audit concludes with a prioritized, actionable plan where each recommendation is grounded in primary-source guidance from Google and carries explicit falsifiability checks — meaning users can verify whether a recommendation succeeded or failed using defined leading indicators.
One of the project's most distinctive design choices is its AI-search-first orientation. Claude SEO aligns with Google's AI Optimization Guide, incorporates question-based citability scoring, checks for llms.txt primary-source evidence, handles IPTC TrainedAlgorithmicMedia metadata for AI-generated product images, and performs agent-friendly page checks per web.dev standards. This positions the tool ahead of most traditional SEO platforms, which have been slow to adapt to the rise of AI Overviews, generative search engines, and LLM citation tracking. The parallel execution model is central to performance: full site audits can spawn up to 15 specialist agents simultaneously, reducing audit time from hours to minutes.
The tool is invoked through 32 user-facing slash commands within Claude Code, organized around an orchestrator and eight categories of sub-skills. Key commands include `/seo audit` for full-site parallel audits, `/seo page` for deep single-page analysis, `/seo schema` for Schema.org detection and validation, `/seo geo` for AI search optimization, `/seo content` for E-E-A-T analysis, `/seo local` for local SEO and Google Business Profile auditing, `/seo drift` for SQLite-backed SEO change monitoring over time, and `/seo ecommerce` for marketplace intelligence. Eight MCP extensions further expand capability, integrating with third-party platforms including Firecrawl for full-site crawling, DataForSEO for live SEO data, Ahrefs for backlink and keyword data, SE Ranking for AI share-of-voice tracking across ChatGPT, Gemini, Perplexity, and AI Overviews, Profound for LLM citation time-series tracking, Bing Webmaster Tools with IndexNow URL submission, and Unlighthouse for multi-page Lighthouse runs.
Core Web Vitals coverage is thorough and up to date: the tool measures LCP (target under 2.5 seconds), INP (target under 200ms, which replaced FID in March 2024), and CLS (target under 0.1), pulling field data from the Chrome User Experience Report (CrUX) and falling back to Lighthouse lab data via PageSpeed Insights. CrUX History spanning 25 weeks is included in the free credential tier. E-E-A-T evaluation is benchmarked against Google's Search Quality Rater Guidelines, last updated September 2025, with expanded YMYL coverage including political and social topics.
Installation is straightforward via Claude Code's plugin marketplace (requiring version 1.0.33 or later), or through manual git clone with shell scripts for Unix/macOS/Linux and PowerShell for Windows. The setup process creates an isolated Python environment and installs Playwright Chromium without touching global system packages. A `/seo doctor` command lets users verify runtime readiness at any time.
The project targets three primary audiences: SEO agencies managing five or more client sites who want to replace quarterly deep audits with weekly automated runs; in-house SEO leads at SaaS, publisher, or e-commerce companies seeking a second-pair-of-eyes before executive reviews; and freelance SEO consultants who want to anchor client engagements with fast, credible, scored audits. The README includes a real Google Search Console screenshot showing organic growth for a site launched March 23, 2026 and run on this workflow through June 2026, offering early evidence of real-world effectiveness
ToolsAgentsMCPworkflow-automationbrowser-use
★ 12,420 total+599 this week
#104
**video-use** is a fully open-source AI-powered video editing tool from the browser-use organization that lets users edit raw footage by chatting with Claude Code (or compatible agents), producing a finished `final.mp4` without traditional editing software. Its core innovation is that the LLM never watches video frames directly — instead it "reads" video through word-level transcripts (via ElevenLabs Scribe) packed into ~12KB markdown files, with on-demand visual composites (filmstrip + waveform PNGs) generated only at decision points, dramatically reducing token overhead versus naive frame-dumping. Key features include filler-word removal, auto color grading, 30ms audio fades, customizable subtitle burning, parallel animation overlay generation via HyperFrames/Remotion/Manim, self-evaluating render loops (up to 3 fix cycles), and persistent session memory. The pipeline follows a strict Ask→Confirm→Execute→Self-Eval→Persist flow. The project is early-stage but technically ambitious, drawing an explicit analogy to browser-use's structured DOM approach. It's trending likely due to the novelty of agent-driven video editing, its zero-UI philosophy, and the growing interest in Claude Code as an agentic shell tool.
ToolsAppsAgentsvideomultimodalbrowser-use
★ 17,880 total+598 this week
#107
CloakBrowser is a stealth-focused browser automation tool that ships a modified Chromium binary designed to pass virtually every major bot-detection test. Its core differentiator is that fingerprints are altered at the C++ source-code level and compiled directly into the binary, rather than being applied through JavaScript injection or runtime flag tweaks. The project's premise is that because the modifications happen inside a real Chromium build, anti-bot systems score it as a genuine browser—since, functionally, it is one. This contrasts sharply with tools like playwright-stealth, undetected-chromedriver, and puppeteer-extra, which inject JavaScript or tweak configs and tend to break with each Chrome update because the patches themselves become detectable. CloakBrowser positions itself as a drop-in replacement for both Playwright and Puppeteer across Python and JavaScript, requiring only an import swap—advertised as "3 lines of code, 30 seconds to unblock." The stealth Chromium binary (~200MB) auto-downloads and caches locally on first run, selecting a free or Pro build depending on the user's license.
The latest release, v0.5.2, is built on Chromium 150.0.7871.114.3 and includes 71 source-level C++ patches covering canvas, WebGL, audio, fonts, GPU, screen, WebRTC, network timing, automation signals, and CDP input behavior. A key feature is the humanize=True flag, which makes mouse movements (via Bézier curves), keyboard timing (per-character typing), and scrolling behave like a real user to defeat behavioral detection. Other notable capabilities include geoip=True (auto-matching timezone and locale to a proxy's exit IP), WebRTC IP spoofing, native SOCKS5 and HTTP proxy support with inline credentials, proxy signal removal (zeroing DNS/connect/SSL timing and stripping proxy cache and Proxy-Connection headers), persistent profiles that retain cookies and localStorage across sessions, Windows native GPU passthrough (using real hardware values instead of spoofed ones), Chrome extension loading via extension_paths, and per-call human_config overrides. The tool auto-generates a random fingerprint seed at startup, so it is stealthy even with zero configuration.
Distribution spans multiple ecosystems: pip install cloakbrowser for Python, npm install cloakbrowser for Node.js (with Playwright or Puppeteer), a community-maintained .NET/C# NuGet package (CloakBrowser) built on Microsoft.Playwright, and a Docker image (cloakhq/cloakbrowser) that offers an instant no-install trial via cloaktest. The project markets a two-tier model: a free latest build (Chromium 150) accessible with a GitHub sign-in allowing one concurrent session, and a paid Pro tier that scales to 5, 20, 200, 2,000, or more concurrent sessions with priority access to the newest patches and hands-on support. An older v146 build remains free on GitHub Releases but is described as aging quickly as detection evolves.
Relevant to the ai-agents query, CloakBrowser explicitly targets AI agents and automation frameworks, advertising drop-in stealth integration with browser-use, Crawl4AI, Scrapling, Stagehand, LangChain, Selenium, and others. This makes it particularly notable for AI agent workflows that require reliable, undetected web browsing at scale. Importantly, the tool does not solve CAPTCHAs—it aims to prevent them from appearing in the first place—and it includes no built-in CAPTCHA-solving services or proxy rotation, expecting users to bring their own residential proxies.
The documented test results are the project's headline selling point. Verified against 30+ live detection services (last tested July 2026 on Chromium 150), CloakBrowser reportedly achieves a 0.9 reCAPTCHA v3 score (human-level, server-verified, versus 0.1 for stock Playwright), passes both non-interactive and managed Cloudflare Turnst
ToolsAppsAgentsbrowser-usesecurityworkflow-automation
★ 29,218 total+555 this week
#108
The **Anthropic Cybersecurity Skills** repository bills itself as the largest open-source cybersecurity skills library purpose-built for AI agents, though it is an independent community project with no affiliation to Anthropic PBC. At its core, it provides **817 production-grade, structured cybersecurity skills** spanning **29 security domains** and mapped across **six major industry frameworks**, making it a uniquely comprehensive resource in the agentic AI security space. The fundamental problem it addresses is well-articulated: modern AI agents can write code and search the web, but they lack the practitioner-level decision-making playbooks that a senior security analyst relies on — knowing when to use a specific Volatility3 plugin, which Sigma rules catch Kerberoasting, or how to scope a cloud breach across multiple providers. This library is designed to close that gap by giving any AI agent structured, executable domain knowledge rather than raw scripts or checklists.
Each skill follows the **agentskills.io** open standard, using YAML frontmatter for rapid discovery and structured Markdown for step-by-step execution. The six framework mappings are a standout feature: every skill is cross-referenced against MITRE ATT&CK v19.1 (286 techniques, 15 tactics), NIST CSF 2.0, MITRE ATLAS v5.4 (AI/ML adversarial threats), MITRE D3FEND v1.3 (defensive countermeasures), NIST AI RMF 1.0, and the newly released **MITRE Fight Fraud Framework (F3) v1.1**, which was published April 9, 2026. No other open-source skills library currently offers this level of unified cross-framework coverage, which is a significant differentiator. The F3 integration is particularly notable: co-developed by MITRE's Center for Threat-Informed Defense alongside major financial institutions including JPMorganChase, Citigroup, Lloyds Banking Group, and Standard Chartered, F3 fills the gap ATT&CK leaves after initial compromise by cataloging cyber-enabled financial fraud TTPs. The repo maps 94 fraud-relevant skills to F3's 123 techniques, covering new fraud-specific tactics like Positioning and Monetization.
The 29 security domains covered include Cloud Security (66 skills), Threat Hunting (58), Threat Intelligence (52), Network Security (43), Web Application Security (42), Digital Forensics (41), Malware Analysis (39), Identity & Access Management (37), SOC Operations (35), Red Teaming (33), Container Security (33), OT/ICS Security (28), API Security (28), and Incident Response (26), among others. The library is compatible with 26+ AI platforms and works immediately with Claude Code, GitHub Copilot, OpenAI Codex CLI, Cursor, and Gemini CLI. Installation is straightforward via npx or git clone. A live playground is available through **Casky.ai**, allowing users to run cybersecurity skill exercises and observe AI agents executing structured skills in real time without any local setup.
The project
ToolsSafetyMCPsecurityworkflow-automationsynthetic-data
★ 26,665 total+555 this week
#113
ARS-Codex (academic-research-skills-codex) is a Codex-native distribution of the Academic Research Skills (ARS) suite, originally designed for Claude Code. It packages the entire ARS workflow as a single unified Codex skill called `academic-research-suite`, adapting the upstream Claude-oriented content through a Codex router layer without modifying the original source. The project is maintained by Imbad0202 and is currently at version 0.1.22, vendoring upstream ARS at v3.19.0 (commit 828ef3b). The repository is licensed under CC BY-NC 4.0 and accepts sponsorship via Buy Me a Coffee.
The core value proposition is enabling OpenAI Codex users to access a sophisticated, multi-workflow academic research pipeline that was previously only available natively in Claude Code. The suite bundles five distinct workflows: `deep-research` for literature reviews and systematic reviews; `academic-paper` for drafting, outlining, and revision; `academic-paper-reviewer` for simulated peer review and editorial decisions; `academic-pipeline` for end-to-end research-to-paper runs with integrity gates; and `experiment-agent` for code experiments, reproducibility validation, and statistical interpretation. A Codex router intelligently dispatches user requests to the appropriate workflow and mode based on the described task.
A notable feature is the emulation of Claude Code's `/ars-*` slash command registry within the single `$academic-research-suite` skill, providing aliases like `ars-plan`, `ars-reviewer`, `ars-full`, and others that map to specific workflow modes. This preserves familiar command semantics across runtimes. The vendored runtime layer adds local-PDF read-integrity preflight sidecars, optional human-read scope attestations with partial-coverage handling, revision-round claim-drift guards using a claim-strength ladder, and deterministic token conservation. Cross-model reviewer/judge tracks, cache re-validation, and risk-stratified claim checks from v3.18 are also preserved.
Installation is supported via Codex CLI plugin commands or direct skill installation using a Python script, with explicit support for both macOS/Linux and Windows (where symlinks are materialized as plain files). The plugin root is `plugins/ars-codex/` and uses a materialized copy of the skill directory for portability. Documentation covers setup, architecture, and an optional full-runtime adapter with a disabled-by-default planner, agent-team templates, and hook packs. Maintainer quality gates can be run via a Python script to verify all integrity checks pass. The project is early-stage (v0.1.x) but architecturally rich, reflecting a deliberate effort to bridge Claude-native academic tooling into the Codex ecosystem — making
ToolsAgentsAppsworkflow-automationcoding
★ 7,152 total+530 this week
#115
**reverse-skill** is a cybersecurity skills router designed to guide AI agents (such as Claude Code, Codex CLI, and Cursor) through structured, repeatable workflows when tackling reverse engineering, penetration testing, CTF challenges, and related security tasks. Instead of letting AI agents guess which tools to use, the package provides a master routing system — via `MASTER-ROUTING.md` and `master-route.ps1` — that maps task types (APK analysis, binary reversing, JS decryption, malware analysis, firmware, EDR bypass, LLM security, etc.) to the correct methodology, toolchain, and playbook. It supports over 20 distinct security scenarios, integrating tools like jadx, apktool, Frida, IDA Pro, radare2, Ghidra, BurpSuite, and nmap across Windows, Linux, macOS, and Kali Linux platforms. The project is at v1.0.0, MIT-licensed (with GPLv3 for the CTF submodule), and is actively trending on Trendshift. Its notable appeal lies in systematizing institutional security knowledge for AI-driven workflows, reducing repeated mistakes and tool confusion — making it highly relevant as AI-assisted security research and agentic coding tools rapidly gain adoption.
ToolsAgentsSafetysecurityworkflow-automationcoding
★ 9,016 total+528 this week
#116
**女娲.skill (Nuwa-skill)** is an open-source Agent Skill that "distills" the cognitive frameworks of world-renowned thinkers and leaders — such as Steve Jobs, Charlie Munger, Elon Musk, Richard Feynman, and Naval Ravikant — into runnable AI perspective skills. Rather than role-playing or quoting famous lines, it extracts each person's mental models, decision heuristics, expression DNA, anti-patterns, and honest limitations into a structured SKILL.md file. The distillation pipeline uses six parallel research agents pulling from 40+ primary sources (books, podcasts, social media, critic perspectives, decision records, life timelines), applies triple-verification filters (cross-domain recurrence, predictive power, exclusivity), and validates outputs against known and novel questions. The project currently ships 14 person skills and 1 topic skill — all independently installable — and every skill has passed a five-dimension blind fidelity scorecard, scoring A-grade (≥85) across the board. It is compatible with 50+ AI agent runtimes including Claude Code, Codex, Cursor, OpenClaw, Hermes Agent, Gemini CLI, and OpenCode, installable via a single `npx skills add` command. Inspired by the viral colleague-skill project, Nuwa extends the concept to history's greatest minds, making it notably trending for its ambition, methodology transparency, and broad runtime compatibility. The project is MIT-licensed and community-extensible.
ToolsAgentsAppsworkflow-automationsynthetic-data
★ 28,847 total+528 this week
#119
CLI-Anything is an open-source project from the HKUDS (Hong Kong University Data Science) lab that aims to make any existing software "agent-native" — meaning AI agents can interact with virtually any application through a unified command-line interface layer. The core philosophy is captured in its tagline: "Today's Software Serves Humans. Tomorrow's Users will be Agents." The project bridges the gap between modern AI agents and the vast ecosystem of existing software tools by generating structured CLI harnesses that agents can invoke programmatically, without requiring those software vendors to build their own agent integrations.
The project's central mechanism is the generation of CLI "harnesses" — thin wrappers around existing applications that expose their functionality as structured, agent-consumable commands. These harnesses output both JSON and human-readable formats, making them compatible with a wide range of AI agent frameworks including Pi, OpenClaw, nanobot, Cursor, and Claude Code. The harnesses are defined through a HARNESS.md specification system, which underwent a major v0.2.0 redesign introducing progressive disclosure — detailed guides are extracted into a `guides/` directory for on-demand loading, with phases 1 through 7 now contiguous and key principles consolidated into a single authoritative section.
A major ecosystem component is CLI-Hub, a package manager and web registry for community-built CLI harnesses. Users can install it via `pip install cli-anything-hub` and then use `cli-hub install <name>` to browse, install, update, and uninstall harnesses. CLI-Hub reached v0.2.0 with support for multiple install sources including pip, npm, brew, and bundled/system tools, backed by a `public_registry.json`. The hub frontend was redesigned to show separate decks for CLI-Anything CLIs and Public CLIs, and live end-to-end checks cover real install, update, and uninstall flows. The registry also supports remote `skill_md` URLs, and all SKILL.md files have been unified under a top-level `skills/` directory installable via `npx skills add HKUDS/CLI-Anything`.
The breadth of supported software is remarkable and growing rapidly. Merged harnesses span creative tools (Blender, Inkscape, FreeCAD, Kdenlive, Shotcut, RenderDoc, Openscreen), productivity and knowledge management (Obsidian, Zotero, Joplin, Calibre), GIS and scientific tools (QGIS, ArcGIS Pro, UniMol Tools), web and automation (n8n, Dify Workflow, Exa, WireMock, Safari, CLIBrowser, DomShell), game development (Godot, Unreal Insights, UEAtelier, Slay the Spire II), cloud and infrastructure (CloudAnalyzer, PM2, ChromaDB, Eth2-Quickstart, SeaClip), media and AI (VideoCaptioner, MiniMax, 3MF), music and data (Rekordbox, LibreOffice, Zoom), and orchestration tools (Hermes skill). Proposed additions include Joplin with 134 tests and ArcGIS Pro for cartography and geoprocessing workflows.
The project demonstrates strong engineering discipline. It reports 2,461 passing tests with 100% pytest pass rates, covering both unit and end-to-end test categories. Security has received explicit attention: Sketch CLI was hardened against path traversal and symlink escapes, DomShell received URL validation and DOM sanitization, XML/SVG/ODF/MLT/MusicXML/CSL parsing now routes untrusted input through `defusedxml`, and Obsidian search was corrected to use proper Local REST API vendor content types. The n8n REPL banner crash was fixed with regression coverage, and LibreOffice headless conversion was made more robust on macOS.
The project is technically grounded in Python (≥3.10) and Click (≥8.0), and is licensed under Apache 2.0. It has an accompanying technical report published on arXiv (arXiv:2606.03854), lending it academic credibility alongside its practical open-source momentum. Documentation is available in English, Chinese, Japanese, and German, signaling broad international community interest.
Community engagement is a defining feature of the project's growth strategy. Contributors can sign up via GitHub issue templates to build new CLI harnesses, and wishlist requests allow users to nominate software they want supported. The project maintains active community channels on Feishu and WeChat. The pace of merges and proposals — often multiple per day — reflects a highly active contributor base, and the Trendshift badge prominently displayed in the README confirms its status as a trending GitHub repository.
The project's real-world demos showcase AI agents using generated CLIs to produce tangible artifacts: CAD builds, 3D scenes, diagrams, gameplay sequences, and video subtitles, among others. These demonstrations underscore the project's practical ambition — not just to expose APIs but to enable agents to operate full creative and professional software pipelines autonomously.
In summary, CLI-Anything is a rapidly maturing, community-driven infrastructure project that sits at the intersection of AI agent tooling and software accessibility. Its combination of a growing harness library, a package manager ecosystem, rigorous testing, security hardening, academic backing, and multilingual documentation makes it a notable and trending project for anyone building or deploying AI agents that need to interact with real-world software.
ToolsAgentsMCPworkflow-automationbrowser-uselocal-first
★ 46,132 total+518 this week
#123
agent-browser is a browser automation command-line interface built by Vercel Labs, purpose-built for AI agents that need to control a real web browser. Its defining characteristic is speed: the tool is implemented as a fast native Rust CLI, and its daemon requires neither Playwright nor Node.js to run, which distinguishes it from many JavaScript-based automation stacks. The project can be installed in several ways to suit different workflows — globally via npm (the recommended path, which installs the native Rust binary), as a pinned local project dependency in package.json, through Homebrew on macOS, via Cargo for Rust users, or built directly from source (requiring Node.js 24+, pnpm 11+, and Rust). After installation, users run `agent-browser install` once to download Chrome from Chrome for Testing, Google's official automation channel; existing Chrome, Brave, Playwright, and Puppeteer installations are auto-detected. On Linux, an `--with-deps` flag installs required system browser libraries, and an `upgrade` command auto-detects the install method (npm, Homebrew, or Cargo) to update accordingly.
The core design philosophy centers on making the browser legible to AI. A key feature is the `snapshot` command, which returns an accessibility tree annotated with references (refs like @e1, @e2) that agents can then use to click, fill, get text, or otherwise interact with elements — a ref-based approach considered "best for AI." Traditional CSS selectors and semantic locators are also supported. The `find` family lets agents locate elements by ARIA role, text content, label, placeholder, alt text, title attribute, data-testid, or positional matchers (first, last, nth), each paired with actions such as click, fill, check, hover, or text, with `--name` and `--exact` refinement options. Implicit ARIA roles are handled (an h2 becomes a heading, a ul a list, a top-level header a banner).
The command surface is broad. Core commands cover opening/navigating URLs, clicking, double-clicking, focusing, typing, filling, key presses, keyboard-level typing and text insertion, hovering, selecting dropdowns, checking/unchecking, scrolling, scroll-into-view, drag-and-drop, file uploads, screenshots (including full-page, annotated with numbered labels, and configurable format/quality/directory), PDF export, JavaScript evaluation (with base64 and stdin input), CDP connection by port, runtime WebSocket streaming (enable/status/disable), and session closing (including `--all`). An AI-powered `chat` command accepts natural-language instructions either as a single shot or in an interactive REPL, enabling conversational browser control. Information-retrieval commands fetch text, innerHTML, input values, attributes, page title, URL, CDP WebSocket URL, element counts, bounding boxes, and computed styles. State checks (`is visible`, `is enabled`, `is checked`) support conditional logic.
A notably sophisticated feature is the `read` command, which fetches agent-friendly text without launching Chrome, or reads the rendered DOM of the active tab (preserving browser auth state and client-side updates). It requests `Accept: text/markdown` by default, retries with an appended `.md` extension, walks ancestor paths to find the nearest `llms.txt` for matching docs links, and falls back to readable text extracted from HTML. Options include `--raw`, `--require-md`, `--outline` (compact heading outline), `--llms index`/`--llms full` (for llms.txt and llms-full.txt), `--filter`, and `--timeout`, plus global safeguards like `--allowed-domains`, `--content-boundaries`, and `--max-output`. Waiting is flexible: agents can wait for elements, time durations, text appearance/disappearance, URL patterns, load states (load, domcontentloaded, networkidle), or arbitrary JavaScript conditions. Batch execution runs multiple commands in a single invocation (as quoted args or piped JSON via stdin) to avoid per-command startup overhead, with a `--bail` option to stop on first error
ToolsAgentsAppsbrowser-useworkflow-automationlocal-first
★ 39,282 total+490 this week
#124NEWPartial week
Nub (nubjs/nub) is a fast, all-in-one JavaScript/TypeScript developer toolkit written in Rust that augments Node.js rather than replacing it, positioning itself as a Bun-like developer experience built on top of stock Node. Its core philosophy is zero lock-in: no new runtime, no vendor-specific APIs, just dramatically faster versions of the tools developers already use. The project consolidates six major developer workflows into a single binary: a TypeScript-first file runner (2.9× faster startup than tsx), a script runner (~24× faster than pnpm run at ~14ms), a package executor nubx (~19× faster than npx), a package manager (~18× faster than pnpm install, powered by the Aube engine), a Node version manager, and a Corepack-style package manager shim system. The file runner is particularly notable, leveraging modern Node.js extension surfaces — including module.registerHooks(), --import/--require preloads, and N-API native addons embedding the oxc transpiler — to support TypeScript, JSX, decorators, extensionless imports, automatic .env loading, built-in data format loaders, and polyfills/unflags for modern APIs like Temporal, WebSocket, node:sqlite, and vm.Module. The package manager includes security-forward defaults: blocking postinstall scripts, checking osv.dev for malicious packages, refusing provenance downgrades, and enforcing a 24-hour minimum release age. Nub detects incumbent package managers (npm, pnpm, Yarn, Bun) and runs in compatibility mode, reading their native config files. It supports installation via curl, Homebrew, Nix, mise, and npm, and provides a GitHub Actions setup action as a drop-in for actions/setup-node. The project is early-stage but ambitious, with comprehensive benchmarks and documentation,
ToolsServingDatalocal-firstsecuritycoding
★ 3,314 total+434 this week
#127NEWPartial week
`astrid-capsule-fs` is a Rust-based filesystem tooling capsule designed for agents running within Astrid OS, a custom operating system built by Unicity Labs. It functions as the coreutils equivalent in the Astrid OS model, providing agents with core filesystem capabilities including reading, writing, replacing content, listing directories, recursive grep search, creating directories, deleting, and moving files. All operations are mediated through a kernel-level VFS (Virtual Filesystem) airlock that enforces path boundaries, copy-on-write isolation, and capability checks before any host filesystem access occurs, emphasizing security and sandboxing. The project targets WebAssembly (`wasm32-unknown-unknown`), suggesting it is designed for a sandboxed, portable runtime environment. It requires Rust MSRV 1.94, indicating it targets a very recent (possibly nightly or upcoming stable) Rust toolchain, which signals active, cutting-edge development. The project is early-stage but purposeful, with notable safety features like rollback on move failure and strict match enforcement for replacements. It may be trending due to growing interest in agent-based OS architectures and Wasm-native system tooling. It is dual-licensed under MIT and Apache 2.0.
ToolsAgentsSafetysecurityon-deviceworkflow-automation
★ 7,404 total+390 this week