#1
REA (Reverse Engineer Anything) is an open-source tool that connects AI agents to a comprehensive suite of reverse engineering capabilities through the Model Context Protocol (MCP). The project's core premise is compelling: if you see a feature in any application and want to understand or replicate it, you can ask your AI agent to investigate it using REA — without needing access to the original source code. REA bridges the gap between high-level agent queries and low-level binary analysis by returning not just conclusions but the underlying evidence and known limitations behind each finding, making it suitable for rigorous technical investigation rather than speculative output.
The tool supports an exceptionally broad range of analysis targets, including native binaries (via Hopper, Ghidra, or IDA), JavaScript and Electron applications, .NET assemblies, Android APKs and live Android devices via ADB, Go and Rust binaries, WebAssembly artifacts, EVM bytecode, SQLite databases, recorded Linux crash dumps, websites via Chrome-family browsers, and saved network captures in HAR or Fiddler SAZ formats. This breadth is a defining characteristic of the project and distinguishes it from narrower, single-target reverse engineering tools.
Setup is streamlined through a single `npx rea-agents setup` command, which registers REA's MCP server with supported agents — including Claude Code, Codex, Cursor, and Gemini CLI — and installs matching workflow instructions with automatic backups. The CLI is equally capable, allowing terminal-based analysis without an agent. REA requires Node.js 22.x or later and npm, with additional dependencies varying by target type. Analysis runs entirely locally, which is a meaningful privacy and security consideration for sensitive targets.
The project is actively maintained and changes rapidly, with frequent bug fixes and a built-in `rea update` command for keeping installations current. It includes careful engineering details such as bounded stdout/stderr retention during updates, terminal backpressure handling, and Bun version compatibility guards, suggesting a mature and production-minded development approach. The README is available in over 20 languages, signaling strong international community investment.
REA is trending on Trendshift and has an active Discord community, indicating growing adoption. Its positioning at the intersection of AI agent tooling and reverse engineering — two of the most active areas in developer tooling — makes it notably relevant. The agent-skills query context aligns directly with REA's MCP-based skill registration model, where agents gain structured reverse engineering capabilities as callable tools. For security researchers, competitive analysts, and developers wanting to understand closed-source behavior, REA represents a significant productivity multiplier by automating the most tedious parts of binary and application investigation.
ToolsMCPSafetysecuritylocal-firstcoding
★ 325,245 total+210,919 this week
#4
dsh-our-free-model is a plugin for the DeepSeek Harness (dsh) runtime that gives users instant, zero-configuration access to a range of frontier AI models—including DeepSeek V4.1 Flash, Kimi K3, GLM 5.3 Flash, and MiMo V2.6—completely free and without usage caps. The core value proposition is that users simply install the plugin into dsh with no login, sign-up, or API key required, and the models become immediately available. The plugin is pure plugin mounting: it does not modify the dsh kernel, requires no build step, and has zero dependencies. Free-lane models are sourced transparently from OpenCode's Zen gateway, while the Kilo channel draws from Kilo AI's public gateway, both connected directly without third-party relays. The model catalog follows upstream dynamically, re-fetching model collections, context lengths, and capabilities on each refresh rather than storing static snapshots. A notable feature is the availability detection logic: the model selector only broadcasts models that are actually routable from the user's own network egress, removing models that upstream explicitly declines (returning "Model is unavailable" or 404) while preserving gateway faults (5xx), rate limits (429), timeouts, and disconnects as still-reachable; region-limited models are grouped separately. The plugin offers an announcement center with real-time push where repo maintainers edit JSON and all installed instances receive updates within one polling cycle, including urgent full-screen popups and optional system notifications. It supports in-app upgrades (download → SHA-256 verification → backup → atomic replace → re-read verification → hot reload, with automatic rollback on failure) and hot reloading without app restart. The plugin handles streaming responses by inspecting response body shape rather than relying on content-type headers, since gateways under high load return SSE frames with application/json content-type. Reasoning/thinking intensity actually takes effect: models with declared tiers use their own Off/Low/High/Max menus passing real reasoning_effort values upstream, while others use a budget ladder (Light/Balanced/Deep mapping to output token budgets of 2,048/8,192/model-max, doubled for models where thinking cannot be disabled). The plugin does not depend on a browser UI, working in compositions like dsh-tui that lack a web server. It includes a usage dashboard with token heatmaps, total curves, output speed, and first-token latency, all kept locally with no data uploaded. An OpenAI-compatible local forwarding port lets other local tools call these models. The EAC channel (desktop-only) unlocks a co-paid lane gated by host fingerprint and server-side GitHub authorization (login and star the repo). The Kilo channel offers a passwordless free pool. An aggregation channel lets users bring their own keys to connect 75 third-party providers (NVIDIA NIM, OpenRouter, Groq, Cerebras, SambaNova, Gemini, DeepSeek, Mistral, Together, Fireworks, and more, plus local providers like Ollama, LM Studio, llama.cpp), with keys written only to local 0600 settings.json. Token-saving features include RTK tool-output compression that rewrites tool_result in place (git diff/status/log, grep, find, etc.), achieving 90% byte reduction on a
ToolsServingAppslocal-firstmultimodal
★ 25,438 total+15,852 this week
#6
Anatomy is a Claude agent skill that explains technical concepts by inventing and rendering physical analogues as crafted, interactive isometric figures. Rather than producing abstract diagrams, it asks Claude to conceive a real mechanical object whose operation embodies the concept being explained — for example, a cache key that skips work when nothing changed becomes a pin-tumbler lock that only opens when every pin aligns, or a single GPU context serving many canvases becomes a gantry plotter whose one print head visits sixteen wells. Claude then constructs that object from dozens of small, solid, shaded parts, places it inside a framed card with a title, a hint, and a live readout, animates it calmly under pointer and keyboard input, and audits its own work by zooming into every joint to verify correctness. Every number displayed in the figure is derived from the same small model that drives the part motion, ensuring visual and logical consistency throughout.
The skill produces three kinds of figure, all sharing one rendering kit, one isometric camera, and one set of craft rules. The core output type is SVG: solid isometric parts with four-tone shading, painted back to front, delivered as a standalone HTML page, a lone embedded SVG file, or React/Next.js components. A second type layers WebGL shaders between a back and front SVG for effects that lines cannot draw — fire, exhaust, water, caustics, lamp light, glow, and steam — while keeping the SVG readable without WebGL. A third type, currently in beta, supports true 3D parts that rotate and re-project every frame, enabling spinning dials, flexing fingers, and falling pieces. Gallery examples include a Raptor 2 rocket engine in a test stand with a WebGL exhaust plume, a school ripple tank with dispersion and optics modeling, a combination dial with a 3D robot hand, and a minimal dial indicator gauge.
The skill is compatible with five AI coding agents: Claude Code, Antigravity, OpenCode, Codex, and MiniMax Code. Installation is handled via the skills CLI with a single npx command, via git clone, or via ZIP download, with no API keys required and zero npm dependencies beyond Node.js 20.10 or later. The CLI supports global and per-project installs and can target specific agents with flags. The repository ships with committed, pre-built example pages that can be opened directly in a browser. Scripts for screenshot capture and browser driving are included. The project is MIT-licensed and carries a passing CI badge, suggesting active maintenance. Its notable qualities for trend analysis include its position at the intersection of agentic AI tooling, the emerging agent-skill ecosystem, and a genuinely novel approach to technical communication — replacing static documentation with generative, interactive mechanical metaphors. The zero-dependency, multi-agent design and broad compatibility across the rapidly growing landscape of AI coding assistants make it a strong signal of where developer tooling is heading.
ToolsAppsmultimodalcodingworkflow-automation
★ 16,239 total+12,409 this week
#7
The `mattpocock/skills` repository, created by Matt Pocock, is a curated collection of AI agent "skills" — small, composable, model-agnostic prompt-based workflows designed to help real engineers build better software with coding agents like Claude Code, Codex, GitHub Copilot, and Gemini CLI. Rather than handing full control to opinionated frameworks like GSD, BMAD, or Spec-Kit, these skills keep the engineer in charge while addressing four core failure modes: misalignment between intent and output, agent verbosity, code that doesn't work, and architectural decay. The flagship skills include `/grill-me` and `/grill-with-docs`, which run structured "grilling sessions" to align the agent with the developer's intent before any code is written. A standout technique is the shared domain language approach, where a `GLOSSARY.md` and Architecture Decision Records (ADRs) are built collaboratively to give agents precise, project-specific vocabulary — reducing token waste and improving naming consistency. The `/tdd` skill enforces a red-green-refactor loop to tighten feedback cycles, while `/diagnosing-bugs` wraps debugging into a disciplined, phase-gated process. The `/improve-codebase-architecture` skill periodically scans codebases for design deepening opportunities and presents them as an HTML report. Skills are split into user-invoked (orchestration) and model-invoked (reusable discipline) categories, and installation takes about 30 seconds via native plugin commands for Claude Code, Codex, Copilot, and Gemini CLI, or via `npx skills` for any other agent. The project draws heavily on canonical software engineering literature — The Pragmatic Programmer, Domain-Driven Design, Extreme Programming Explained, and A Philosophy of Software Design — grounding AI-assisted development in decades of proven practice. With a newsletter following of ~60,000 developers and active plugin marketplace presence, the repo is clearly gaining significant traction in the AI-assisted engineering space and represents a principled, anti-"vibe coding" philosophy.
ToolsAgentscodingworkflow-automation
★ 296,439 total+9,888 this week
#11
Diagram Design (cathrynlavery/diagram-design) is an "agent skill" that generates editorial-quality diagrams by having an AI coding agent draw them as a single self-contained HTML file with inline SVG, styled in the user's brand. Rather than writing diagram markup (as with Mermaid or PlantUML) or dragging shapes by hand (as with draw.io or Excalidraw), users describe the diagram they want in plain natural language to their agent, which then selects the appropriate diagram type, states its plan, and writes a `.html` file that can be opened by double-clicking. The project supports 45 diagram types and deliberately avoids generic defaults like drop shadows and what it calls "Mermaid slop," aiming for one opinionated, polished editorial style that designers "won't hate." Example prompts include requesting an application architecture diagram (frontend, backend, database, Redis cache), an impact-versus-effort quadrant of projects, or a sequence diagram of a bearer token call with refresh on a 401 response. A distinctive onboarding feature lets users point the skill at their website URL so it pulls the site's palette and fonts, ensuring every subsequent diagram matches their brand identity.
The skill is designed to work across many agent hosts that read the Agent Skills format, including Cursor, Claude Code, Codex, GitHub Copilot, Gemini CLI, Cline, Windsurf, Amp, Zed, Warp, Roo, Kilo, Factory Droid, Claude Cowork, Pi, Kiro, and OpenCode. The primary install path is the cross-agent `skills` CLI via `npx skills add cathrynlavery/diagram-design`, which resolves the repository, detects the `SKILL.md` file, and installs the full skill (references, assets, scripts) into every selected host root, recommending symlinks so a single canonical copy can be updated everywhere at once (with a `--copy` flag and Windows fallback behavior). Claude Code additionally offers a plugin marketplace with slash commands (`/export-diagram`, `/import-mermaid`, `/import-excalidraw`, `/profile`, `/doctor`) and optional auto-update. The README provides detailed, host-specific installation and update instructions for Codex, GitHub Copilot, Factory Droid, Claude Cowork (requiring a private/internal organization mirror), Pi, Kiro, and OpenCode, plus an editable-install path for users who clone the repo and symlink it to customize the style guide directly. Saved profiles live in `~/.diagram-design/profiles/` and survive updates. The project emphasizes provenance: official builds come only from this repository, and LittleMight (Cathryn Lavery's company) publishes the official directory listings, with any other name being an unofficial copy; a PRIVACY.md documents what data the skill transmits over the network.
Key features include agent-placed layout on a 4px grid with continuous integration checks for element overlaps and clipping, export to SVG and PNG, and the ability to redraw/import existing diagrams from Mermaid, draw.io, and Excalidraw files. The README includes an honest comparison table against Mermaid/PlantUML and draw.io/Excalidraw, and candidly acknowledges downsides: output quality depends on the underlying model, the same prompt can produce different layouts on repeat runs, and the result is not an editable source format—there is no text to diff in a pull request and no canvas to manually adjust. For documentation living in Git that changes every sprint, the author concedes Mermaid remains a better fit; Diagram Design is positioned instead for diagrams you intend to publish.
In terms of maturity, the project shows signs of being an actively maintained,
ToolsAppsAgentscodingmultimodalworkflow-automation
★ 57,867 total+7,117 this week
#18
Ponytail is an AI agent skill — essentially a single, carefully engineered prompt — that embeds the philosophy of a "lazy senior developer" into coding agents like Claude Code, Codex, Copilot, Cursor, and others. Rather than generating verbose boilerplate, it instructs the agent to climb a prioritized "ladder" before writing any code: first questioning whether the feature needs to exist at all, then checking the existing codebase, the standard library, native platform features, installed dependencies, and one-liners, before finally writing the minimum necessary implementation. The result is dramatically leaner output without sacrificing correctness or safety — validation, error handling, security, and accessibility are explicitly protected from cuts. Ponytail 5, the latest major release, was benchmarked against a baseline (same agent, no skill) across 39 tasks on a real FastAPI + React repository using Claude Opus 5.5, producing -53% code, -41% time, -26% cost, and -45% tokens, while raising the rate of risky logic shipped with tests from 68% to 98%. Two rebuilt commands ship with it: `/ponytail-review`, which reads beyond the diff to catch bugs, security issues, missing tests, and performance problems, and `/ponytail-audit`, which maps an entire repo's data flow and ranks issues by severity. Version 5.3 adds a "band" — a live HUD above the Claude Code prompt showing cost, token usage, agent time, code-reuse rate, and test status — plus a local dashboard board aggregating sessions across projects. The skill is distributed as a single Markdown file (`SKILL.md`) installable via plugin marketplaces or by copying `AGENTS.md` into any project. It is actively trending on Trendshift (daily, weekly, and monthly JavaScript rankings), has an npm package, and is already used in production by at least one named product. Its notable claim is that smaller code is a side effect of necessity, not token-golfing.
ToolsAgentsAppscodingsecurityworkflow-automation
★ 167,193 total+5,960 this week
#19
HyperFrames is an open-source framework developed by HeyGen that converts HTML, CSS, media assets, and seekable animations into deterministic MP4 video files. The core value proposition is elegantly simple: write standard web markup and render it as video, making the tool accessible to both human developers and AI coding agents. It is distributed as an npm package, requires Node.js version 22 or higher, and is licensed under Apache 2.0, signaling a serious commitment to open-source adoption. The project is notably positioned as "built for agents," meaning it is explicitly designed to be operated by AI coding assistants rather than just human developers, which is a distinctly modern and trending architectural philosophy in developer tooling.
The framework ships with 21 skills — modular capability units that AI agents load on demand — organized around a central router skill called `/hyperframes` that acts as an intent layer and capability map. This router interprets natural language requests like "make me a product intro video" and dispatches to the appropriate creation workflow skill. Creation workflow skills cover a wide range of video production scenarios: product launch videos generated from a website URL, faceless explainer videos built entirely from LLM-invented visuals, GitHub pull request changelogs turned into video summaries, embedded caption overlays for talking-head footage, motion graphics, beat-synced music videos, presentation slide decks, and general freeform compositions. There is even a dedicated skill for porting existing Remotion (React-based) compositions into HyperFrames HTML, signaling awareness of the competitive landscape.
Domain skills handle atomic technical layers such as the composition contract (timing attributes, tracks, sub-compositions), animation knowledge spanning GSAP, Lottie, Three.js, Anime.js, CSS, WAAPI, and TypeGPU, and seek-safe keyframe authoring across all those runtimes. This layered skill architecture allows agents to compose complex video production pipelines from well-defined, reusable building blocks without needing to understand the entire framework at once.
Integration with AI coding agents is a first-class concern. HyperFrames supports Claude Code via a versioned marketplace plugin, Codex via a packaged ZIP archive, and standalone skill installation via the `skills` CLI for tools like Cursor, Gemini CLI, IBM Bob, VS Code Copilot, and OpenCode. The project maintains careful distinctions between interactive and non-interactive installation modes to ensure agent-driven workflows install exactly the right skill subset without bloat. A native desktop application for Mac and Linux is also available, broadening accessibility beyond CLI-only usage.
The project provides a Studio, a Playground, a Showcase, a Quickstart guide, a Catalog of pre-built blocks, and full documentation, suggesting a maturing ecosystem rather than a raw prototype. The combination of a polished developer experience, agent-first design, broad animation runtime support, and backing from HeyGen — a well-known AI video generation company — makes this repository particularly notable. It sits at the intersection of two major trends: AI agent tooling and programmatic video generation, positioning it as infrastructure for the next generation of automated content creation pipelines. The explicit support for deterministic rendering is also significant, as it ensures reproducibility, a critical property for production video workflows driven by non-human agents.
ToolsAppsMCPvideocodingworkflow-automation
★ 66,916 total+5,797 this week
#26NEWPartial week
**gitai** is an open-source, MIT-licensed version control system purpose-built for AI coding agents, inspired by Anthropic's internal **Scion** system described in the "Redesigning Source Control" engineering post. Where classic Git hosting was designed for humans pushing infrequently, gitai targets scenarios with hundreds or thousands of short-lived agents concurrently reading, writing, and landing code on shared branches. Its core innovations include server-side history operations (blame, ancestry, search) with memoization, a compare-and-swap landing mechanism that batches concurrent changes without a merge queue, a changeset write-ahead log, and stateless server nodes backed by SQLite/PostgreSQL plus object storage (S3, GCS, Azure). Conflict resolution is pluggable—any LLM provider, deterministic tool, or none. Benchmarks show dramatic improvements: 50 agents landing 250 changes achieve ~1,862–2,544 lands/minute vs. 240–272 for classic Git, with p99 latency dropping from ~7s to ~1.8s. The project is at version 0.2.0, forked from GitLab's Gitaly, vendor-neutral (the server never calls an LLM directly), and community-maintained. It is notable as the first public implementation of Anthropic's Scion design, making agent-scale version control accessible to everyone.
ToolsAgentsMCPcodingworkflow-automationsynthetic-data
★ 2,316 total+4,431 this week
#28
Taste Skill is an open-source collection of Agent Skills designed to elevate AI coding agents from assembling generic landing pages into genuinely art-directed, design-conscious frontend builders. Rather than producing average output, the default skill guides agents through a structured six-step creative process: reading a client brief, drawing from 20 researched art directions, forming a unifying design idea, sourcing real photographs from open archives, checking the rendered page in a live browser at three widths, and iterating on its own screenshots to fix the top visual problems — up to three rounds. The methodology was derived from a study of 247 curated websites and the latest 100 Awwwards Sites of the Day, giving it a research-backed aesthetic foundation rather than relying on generic heuristics. Version 2.1 extends the skill to dashboards and app screens, dealing styles distilled from real product UIs and enforcing app-specific rules: quiet panels, data-driven color, aligned figures, and collapsible mobile navigation. A companion desktop application, TasteCode, packages the skill into a standalone design agent that briefs, builds, and visually reviews UI — free and open source. The project is compatible with the Vercel Labs Agent Skills CLI and integrates with Claude Code, Codex, and Cursor. Installation is a single npx command with no API keys required, needing only Node 22+ and a Chromium-based browser. Seven classic skills from earlier versions remain available as opt-in alternatives, including soft, minimalist, brutalist, and GPT-specific variants, some featuring tunable dials for design variance, motion intensity, and visual density. Image-generation skills have been spun off into a separate repository. The project is MIT-licensed, actively maintained with a public changelog, and sponsored by several developer-focused companies. Its notable trend signal lies at the intersection of AI agent tooling, design quality enforcement, and the growing demand for agents that produce premium rather than mediocre frontend output — a timely and differentiated niche as AI-generated UI proliferates.
ToolsAppscodingbrowser-usevision
★ 98,946 total+4,139 this week
#35NEWPartial week
**qwen21-nsfw-pose-skill** is a comprehensive ComfyUI-based recipe for generating NSFW and pose-controlled images using the Qwen-Image 2.1 int8 model, designed to replicate Civitai author-quality outputs. It combines author-structured prompts, NSFW LoRAs, a curated library of 136 3D poses, and VNCCS puppet-based precise pose control. The project supports four generation routes: text-to-image with NSFW LoRA, character image editing, script-based pose transfer using 3D doll renders, and interactive VNCCS PoseStudio via browser automation. It includes a self-diagnostic script (`doctor.py`), detailed hardware guidance (minimum 12GB VRAM, recommended 24GB), and macOS Apple Silicon notes. The repo targets both AI agents (Claude Code, Codex, Cursor, OpenClaw) and manual human use, with a boldness ladder (L0–L3) for content intensity. Licensed under Apache 2.0 for original code, with third-party assets retaining their respective licenses. The project is notably trending due to its structured, reproducible NSFW generation pipeline built on a cutting-edge multimodal model with verified author-sample replication.
ToolsAppsModelsmultimodalvisionbrowser-use
★ 3,047 total+3,510 this week
#37
Free Claude Code (FCC) is an independent, open-source proxy and orchestration layer that enables developers to run multiple AI coding agents against a wide variety of free, paid, subscription, and local model providers — all from a single unified interface. The project's central value proposition is access to 61 Terms-of-Service-friendly providers delivering over 1.3 billion free tokens per month, without putting user accounts at risk, since FCC actively monitors provider policies and removes integrations that fall out of compliance. Rather than locking users into a single model or vendor, FCC exposes a searchable model catalog that works across 11 distinct coding agents: Claude Code, Codex, Pi, OpenCode, Cline, Hermes, DeepSeek Harness, Grok Build, Muse Code, Aider, and VS Code Chat. This breadth of agent support is a standout feature, making FCC a kind of universal adapter for the rapidly expanding AI coding agent ecosystem.
A key reliability feature is automatic provider failover: when retries are exhausted on one provider, FCC seamlessly routes the request to the next configured model without requiring the user to restart their session, and this works across every supported client. Token efficiency is another focus — optional integrations with RTK and Headroom can reduce token consumption by up to 90% by filtering command output and compressing tool results, which is especially valuable for users on free-tier limits. FCC also supports native browser-based coding sessions, allowing users to pick a folder and run Codex directly in the browser with real-time and background support, with the ability to switch providers and models mid-session.
The project supports a remarkably wide range of client surfaces: terminal, desktop launchers, VS Code, JetBrains IDEs, the Codex App, Discord, and Telegram. Voice input is supported via local OpenAI Whisper or NVIDIA NIM transcription, enabling a "voice notes in, code out" workflow. Advanced agent capabilities are preserved throughout, including streaming responses, tool use, native interleaved thinking, image support, and independent routing of Claude model tiers (Fable, Opus, Sonnet, Haiku) to compatible upstream models.
The provider catalog is extensive and spans major commercial APIs (OpenAI, Anthropic, Google Gemini, xAI Grok, DeepSeek, Mistral, Cohere, Amazon Bedrock, Azure OpenAI, Google Vertex AI, Hugging Face), subscription/OAuth providers (ChatGPT, GitHub Copilot), and numerous free or freemium services (OpenRouter, Groq, ClinePass, Nebius, Chutes, Featherless AI, SiliconFlow, Together AI, DeepInfra, QwenCloud, Alibaba Cloud, W&B Inference, Vercel AI Gateway, Wafer, Kimi, ZenMux, Agnes AI, and more). Custom provider endpoints can also be added manually via the Admin UI.
Installation is straightforward via shell scripts for macOS/Linux and PowerShell for Windows, with native desktop launchers and system tray/menu-bar integration on Windows and macOS. The project is built on Python 3.14, uses uv for package management, Ruff for formatting, ty for type checking,
ToolsServingAgentscodingmultimodalaudio
★ 61,629 total+3,490 this week
#39
Archify is a free, open-source AI agent skill that transforms natural language descriptions, questions, or plans into interactive, self-contained HTML visuals — including architecture diagrams, explainer pages, learning maps, travel itineraries, and complex system maps. The core premise is elegantly simple: describe an idea or system to your AI coding agent, and Archify generates a polished, interactive HTML file you can explore, customize, and share without needing a repository or any pre-existing codebase. It is installed via a single `npx skills add tt-a1i/archify -g` command and integrates natively with popular AI coding environments including Cursor, Claude Code, Codex CLI, and OpenCode, making it immediately accessible to a wide developer audience.
The project's approach centers on two primary output modes. The first is interactive architecture diagrams: users describe a system — for example, a web request flow involving a browser, API, Redis cache, and PostgreSQL database — and Archify renders it as a navigable, source-linked diagram. Users can then iteratively refine it by asking the agent to add authentication layers, highlight specific paths, or switch themes, making it a genuinely conversational diagramming tool. The second mode is the "explainer page," a richer single-page document that leads with a conclusion, then breaks down a complex question panel by panel, weaving together tables, step-by-step instructions, charts, code snippets, and validated diagrams. Steps sit beside the diagrams they describe and highlight relevant nodes as the reader progresses, creating a tightly integrated reading experience. Claims in explainer pages cite numbered sources, repository excerpts are pinned to specific commits, and the entire output is exportable as PNG, WebP, JPG, or PDF — making it suitable for sharing with non-technical stakeholders.
Archify is at a mature and actively maintained stage, currently at version 3.2.0, and has accumulated over 130,000 installs on skills.sh, a significant adoption signal for a developer tool in this category. It is tracked on Trendshift (repository #31352), indicating measurable and notable momentum in the open-source community. The README is available in English, Simplified Chinese, Japanese, and Korean, reflecting a deliberately international user base and community strategy. Community channels span Discord, WeChat, and QQ, suggesting strong engagement particularly in East Asian developer communities alongside Western ones.
The project's sponsor ecosystem is notably robust for an open-source tool of this type. Sponsors include Kimi Work (which features Archify as a plugin under the name "Interactive Architecture Diagram"), Supercode (which named it an Editor's Choice skill and focuses on token optimization and spec-driven development), OpenLux (an AI model aggregation platform offering Claude, OpenAI, and Gemini at deeply discounted rates), PackyCode (a unified API gateway with automatic failover for Codex and Claude Code), AICodeMirror (an API relay service for Claude, Codex, and Gemini), Infistar.cc (a multi-model API platform covering text, image, and video), and EverMind/Raven (a memory infrastructure project for agents that supports Archify as a verified skill). This breadth of sponsorship from AI infrastructure and API relay companies signals that Archify sits at a commercially interesting intersection of agent tooling and developer productivity.
What makes Archify particularly notable from a trend analysis perspective is its positioning squarely within the agent-skills ecosystem — a rapidly growing category where reusable, composable capabilities are installed into AI coding agents rather than run as standalone applications. Its 130K+ install count, multi-language documentation, Trendshift tracking, and multi-sponsor backing collectively suggest it is one of the more traction-heavy projects in this emerging space. The ability to produce shareable, self-contained HTML artifacts from pure natural language, without requiring a repository, lowers the barrier to entry dramatically and broadens its appeal beyond software engineers to anyone who needs to communicate complex ideas visually.
ToolsAppsAgentscodingworkflow-automationmultimodal
★ 85,485 total+3,318 this week
#40
The `addyosmani/agent-skills` repository is a collection of 25 production-grade engineering skills designed for AI coding agents, authored by Google Chrome engineer Addy Osmani. The core idea is to encode the workflows, quality gates, and best practices that senior software engineers follow — and package them so AI agents apply them consistently across every phase of the software development lifecycle. Rather than leaving agents to improvise, each skill is a structured workflow with explicit steps, verification gates, and anti-rationalization tables that prevent agents from cutting corners (e.g., silencing checks or skipping tests to appear green).
The lifecycle is organized into six phases — Define, Plan, Build, Verify, Review, and Ship — each mapped to a slash command: `/spec`, `/plan`, `/build`, `/test`, `/review`, and `/ship`. Additional commands include `/constraints`, `/webperf`, and `/code-simplify`, covering quality thresholds, web performance auditing, and code clarity respectively. A power-user mode, `/build auto`, lets the agent generate a plan and implement every task autonomously in a single approved pass, pausing only on failures or risky steps, while still enforcing test-driven development and individual commits per task.
Skills also activate contextually and automatically — designing an API triggers the `api-and-interface-design` skill, building UI triggers `frontend-ui-engineering`, and so on. The pack ships 25 skills total, including a meta-skill (`using-agent-skills`) that maps incoming work to the correct workflow, plus skills for idea refinement, spec-driven development, constraint-driven development, incremental implementation, test-driven development, code review, debugging, and more.
Installation is broadly supported. The fastest path is a single `npx skills add addyosmani/agent-skills` command via the open skills CLI, which installs into 70+ agents. Native integrations are documented for Claude Code (the recommended host, with marketplace plugin support), Cursor, Codex, GitHub Copilot, Windsurf, Gemini CLI, Antigravity CLI, OpenCode, Kiro IDE, and Command Code. Skills are plain Markdown, making them compatible with any agent that accepts system prompts or instruction files. A known portability gap exists when installing individual skills without the shared `references/` directory, tracked in issue #361.
The repository includes an Adoption Guide covering two rollout paths: a full lifecycle approach for greenfield projects and an incremental, verification-first rollout for established codebases. The project is trending on Trendshift (ranked repository #25200), signaling strong community interest. Its notable qualities are its breadth of agent compatibility, its opinionated but practical engineering philosophy (spec before code, small atomic tasks, tests as proof), and its ambition to make AI agents behave more like disciplined senior engineers rather than fast-but-sloppy code generators.
ToolsAgentsAppscodingworkflow-automation
★ 108,273 total+3,136 this week
#41
Agent Reach is an open-source Python (3.10+) agent-infrastructure toolkit that gives AI agents one-click internet access across a wide range of platforms — including Twitter/X, YouTube, Bilibili, Reddit, Facebook, Instagram, Xiaohongshu (Little Red Book), LinkedIn, GitHub, RSS feeds, and general web pages — without requiring users to manually configure each integration. Its core design philosophy is a "capability layer" that sits above individual tools: it selects the currently most stable backend for each platform, installs it, health-checks it, and routes around failures automatically. Each platform is represented as an ordered list of primary and fallback backends (e.g., Bilibili switched from yt-dlp to bili-cli after B站's anti-scraping blocked yt-dlp in June 2026), so when one integration breaks, Agent Reach silently reroutes with zero user action. Installation is triggered by a single natural-language instruction to any compatible agent (Claude Code, OpenClaw, Cursor, Windsurf, etc.), and the built-in `agent-reach doctor` command diagnoses which channels are live and which need repair. Security is a first-class concern: credentials and cookies are stored locally at `~/.agent-reach/config.yaml` with 600 permissions, never uploaded; the installer defaults to read-only environment checks and only modifies the system when `--system` is explicitly passed; a `--dry-run` flag previews all actions. The project is fully open-source under MIT, supports multilingual documentation (Chinese, English, Japanese, Korean), and has achieved GitHub Trending #1 Repository of the Day on Trendshift, signaling strong community momentum. Sponsors include BrowserAct, Tencent Cloud, CoreClaw, and UCloud AstraFlow, reflecting commercial interest in the agent-infrastructure space. Its notable trend relevance lies in addressing the rapidly growing need for reliable, maintainable internet-access tooling for autonomous AI agents, a pain point that is becoming critical as agent usage scales.
ToolsMCPAgentsbrowser-useworkflow-automationsecurity
★ 99,165 total+3,012 this week
#44
Moli is a production-ready, open-source headless browser purpose-built for AI agents, developed by Lexmount. Its defining architectural innovation is an "on-demand layout and rendering" model: rather than continuously maintaining a fully rendered visual state, Moli treats the native DOM and CSS style as the single source of truth and triggers layout or paint only when an operation genuinely requires it. This makes it exceptionally fast and resource-efficient for the kinds of tasks AI agents actually perform — fetching pages, extracting structured content, querying the DOM, running JavaScript, and automating browser interactions — without the overhead of a traditional browser's continuous rendering pipeline. Moli is not a Chromium wrapper; it is a standalone browser kernel written in Rust, integrating V8 for JavaScript execution, Servo/Stylo for CSS cascade, Taffy and Parley for box and text layout, html5ever for HTML parsing, libcurl for networking, and Vello CPU/usvg for software rendering. It supports all three major automation protocols — CDP, WebDriver Classic, and WebDriver BiDi — from a single unified binary, meaning no separate ChromeDriver, geckodriver, or browser installation is needed. Playwright can connect to it directly over CDP. The CLI supports rich extraction outputs including Markdown, HTML, JSON, semantic text trees, screenshots, and PDFs, with fine-grained control over resource loading, proxies, profiles, and page-load strategies. Expensive operations like layout, screenshots, and media resource fetching require explicit opt-in flags, giving developers precise cost control. Moli runs on Linux, macOS, and Windows, and is fully usable as a standalone open-source tool independent of Lexmount's managed cloud offering, Lexmount Browser. It is already trending on Trendshift (both daily and weekly Rust rankings), signaling strong community momentum. Its architecture is particularly well suited to crawling pipelines, browser-use agents, retrieval-augmented generation systems, evaluation environments, and reinforcement-learning workloads, making it highly relevant to the current surge in agentic AI development.
ToolsAgentsRetrievalbrowser-uselocal-firston-device
★ 19,515 total+2,925 this week
#45
The `cloudflare/security-audit-skill` is an AI coding-agent skill that transforms a coding agent into an automated security auditor, orchestrating isolated sub-agents through six structured phases: reconnaissance, coverage-led hunting, candidate validation, structured output, independent record verification, and target-neutral reporting. It originated as the seed for Cloudflare's internal vulnerability discovery harness, described in their engineering blog, and has since evolved into a multi-stage, fleet-wide system — making this repo the single-repo starting point of that effort. Key features include a coverage ledger to track and close audit gaps across multiple runs, adversarial validation (a different agent always verifies a finding), and strict verdict categories (`confirmed`, `needs_validation`, `rejected`). The skill ships with specialized attack-class prompt files covering memory safety, AI/LLM targets, web/auth protocols, supply chain, cloud/IaaS, client-side, and more. It requires Node.js for zero-dependency validators and a sandboxed OS environment for safe code execution. Notable for its production-proven lineage, rigorous multi-run additive coverage model, and open MIT license, it is likely trending due to growing interest in AI-driven automated security tooling from a major infrastructure company.
ToolsSafetyAgentssecuritycodingworkflow-automation
★ 31,237 total+2,846 this week
#47
CLI-Anything, developed by the HKUDS group, is an ambitious open-source project built on the premise that while today's software is designed to serve human users, tomorrow's users will increasingly be AI agents. The project's core mission is to make virtually any software "agent-native" by providing command-line interface (CLI) harnesses that bridge the gap between AI agents and the world's existing software applications. With a single command line, CLI-Anything makes any piece of software agent-ready for a variety of AI coding agents and assistants, including Pi, OpenClaw, nanobot, Cursor, and Claude Code. This effectively transforms conventional applications into tools that autonomous agents can operate directly. A central component of the ecosystem is CLI-Hub, a package manager installable via `pip install cli-anything-hub`, which lets users browse, search, install, update, and uninstall community-built CLIs using commands like `cli-hub install <name>`. The Hub features a web frontend with separate decks for CLI-Anything CLIs and Public CLIs, and it supports installation from multiple sources including pip, npm, brew, and bundled/system tools, backed by a public registry JSON file. The project emphasizes community contribution: developers can open pull requests to add new CLI harnesses, sign up as contributors, or submit wishlist requests for software they want supported, with the hub updating instantly upon merges. Technically, the project is Python-based (requiring Python ≥3.10) and uses the Click library (≥8.0) for CLI construction, supporting both JSON and human-readable output formats. It demonstrates notable maturity through extensive testing, boasting 2,461 passing tests with both unit and end-to-end (e2e) coverage using pytest, and it is released under the Apache 2.0 license. The project provides 18 demonstration apps and real-world demos showing AI agents using generated CLIs alongside preview, live preview, and trajectory loop features to produce tangible artifacts such as CAD builds, 3D scenes, diagrams, gameplay, and subtitles. Documentation is available in multiple languages including English, Chinese, Japanese, and German, and the community connects through Feishu and WeChat groups. The project has a strong trending signal, prominently displaying a Trendshift badge and refreshing its README presentation to emphasize discovery and project momentum. The news log reveals an extremely active development pace with near-daily updates and a rapidly growing catalog of merged and proposed CLI harnesses across diverse domains. Merged and proposed CLIs span creative tools (Blender, FreeCAD, Inkscape, Draw.io, Kdenlive, Shotcut, Sketch, Openscreen screen recording, VideoCaptioner), knowledge management (Obsidian, Zotero, Joplin, Calibre), GIS and mapping (QGIS, ArcGIS Pro), 3D and game development (Godot, Unreal Editor via UEAtelier, Unreal Insights, RenderDoc, Slay the Spire II, 3MF mesh tools), automation and workflows (n8n, Dify Workflow, PM2, WireMock, Zoom), scientific and molecular modeling (UniMol Tools, py4csr, ChromaDB), blockchain (Eth2-Quickstart Ethereum staking), audio and media (MiniMax TTS, Rekordbox), web search and browsing (Exa, Safari, CLIBrowser, DomShell, SeaClip), cloud analysis (CloudAnalyzer), and OSINT (IntelWatch). Recent updates include a Hermes orchestration skill, security hardening efforts such as routing untrusted XML/SVG/ODF/MLT/MusicXML/CSL input through defusedxml, path-traversal protections for Sketch CLI token handling, and guarded SQLCipher write paths for Rekordbox. The project also unified all SKILL.md files under a top-level `skills/` directory, enabling installation from one canonical source via `npx skills add`, and it added root-skill validation CI. Architecturally, version 0.2
ToolsAgentsMCPworkflow-automationcodingbrowser-use
★ 54,731 total+2,800 this week
#50
Caveman is an open-source token-reduction toolkit for AI coding agents that makes agents "say less and read less" without sacrificing answer quality or code correctness. The core philosophy, captured in its tagline "why many token when few do trick," is that AI agents waste enormous amounts of tokens on verbose prose, redundant logs, and bloated file reads — and that stripping this waste down to essentials saves money and time while preserving correctness. The project is structured around six modular "rocks," all enabled by default after a single install command. The first rock, "Say less," applies a structured caveman voice to agent responses — a controlled English style inspired by ASD-STE100 aircraft maintenance standards — reducing output tokens by 35–65% compared to verbose defaults while keeping code, commands, and error messages character-perfect. The second rock, "Read less," compresses logs, CSVs, JSON, YAML, and test output before the model reads them, achieving 33.2% fewer input tokens across whole sessions in benchmarks where 18 of 18 answers remained correct. The third rock, "Auto," dynamically selects the model and effort level per task, cutting costs by 54% compared to always running Claude Opus at maximum effort across 85 real coding tasks with no measurable quality loss. The fourth rock, "Blocks," caches scripts the agent writes in code mode and reruns them rather than regenerating, shrinking one test run from 397 to 76 tokens. Additional rocks handle waste detection, prompt cache warming during pauses, and web page compression (achieving up to 129.8× smaller pages). The project has attracted significant external validation: Adobe Research cited it in a formal paper (CAVEWOMAN) showing 1.4–2.4× cost reductions across eight models; Elastic remade it for Elasticsearch and reported 63.6% fewer response tokens with zero information loss; and JetBrains ran a paired A/B test across 86 coding tasks finding no measurable quality loss (p = 0.82). Caveman reached #1 on Hacker News and #1 on GitHub Trending, and was reviewed by prominent developer content creator ThePrimeagen. It supports 30+ agents including Claude Code, Codex, Gemini CLI, and OpenCode, installs via a single npx command, and requires Node.js 22.13+. The project is notably honest about its limitations, publishing cases where caveman loses and flagging that HTML compression is not yet implemented. At version 4.0, it is actively maintained and maturing rapidly, making it a notable trending project at the intersection of AI cost optimization, developer tooling, and LLM efficiency research.
ToolsServingTrainingcodingworkflow-automationon-device
★ 113,507 total+2,421 this week
#52
**Humanizer** is an agent skill that rewrites AI-generated text to sound like it was written by a human, without altering the underlying facts or meaning. It is grounded in Wikipedia's "Signs of AI Writing" guide — the same reference Wikipedia editors use to identify AI-generated content — giving the project a credible, well-documented theoretical foundation. The tool integrates directly into AI coding and writing agents including Claude Code, Codex, Gemini CLI, GitHub Copilot, and Windsurf via the Skills CLI, and can also be installed manually in Claude.ai and Claude Desktop. Its core approach involves detecting and rewriting 26 named patterns of AI writing, organized into six categories: staging instead of stating, rhythm by rule, inflation and borrowed authority, formatting by rule, chat/draft leftovers, and writing for the wrong reader. The five strongest tells — constructions like "Not X but Y," one-line dramatic closers, pseudo-profound sayings, staged run-ups, and arguing with no one — each justify an edit on a single occurrence. Humanizer also supports voice matching: paste a few paragraphs of your own writing and it will mirror your rhythm, word choice, punctuation, and deliberate quirks. It explicitly does not aim to fool AI detectors, focusing instead on genuine readability for human audiences. In a blind evaluation, judges preferred Humanizer's rewrites over the original AI text in all 16 of 16 trials. The project is sponsored by cfo.ai and distributed through the skills.sh marketplace, signaling early but active commercial backing. Its combination of a rigorous pattern taxonomy, multi-agent compatibility, and a strong empirical result makes it a notable and practically useful tool in the growing space of AI-output post-processing.
ToolsAppsworkflow-automation
★ 58,173 total+2,315 this week
#54
**text-to-cad** is an open-source plugin that gives AI coding agents the ability to generate and manipulate 3D CAD models directly within their workflows. The project allows agents to produce 3D files in standard formats — STEP, GLB, STL, and 3MF — from natural language prompts, and extends further into design-for-manufacturing (DFM) checks, engineering drawing generation, and direct integration with 3D printing, sheet metal, and CNC fabrication services. At its core, the plugin wraps the `cadgen` Python package (built on `build123d` and Open CASCADE) and exposes CAD capabilities as agent-callable skills via the `skills.sh` framework and MCP (Model Context Protocol) server architecture. The project is notably broad in agent compatibility, supporting Claude Code, Claude Desktop, Codex, Cursor, Gemini, and Grok Build — essentially any agent platform that supports plugins or the skills framework. Installation is designed to be agent-driven: users can simply tell their agent to install text-to-cad from the GitHub URL, and the agent handles the rest using `uv` as the Python runtime manager. Each supported agent platform has tailored install, update, and uninstall commands, and the plugin includes an integrated CAD viewer that renders 3D models inline in conversation UIs where supported, or via a localhost browser viewer otherwise. The project ships with telemetry enabled by default (anonymous, no file paths or prompts), which can be disabled via a CLI command or by asking the agent. It is MIT-licensed, actively tested via GitHub Actions CI, and versioned on PyPI as `cadgen`. The project appears to be in active, rapid development — the README references versioned releases, a `latest` branch strategy, and a growing set of skills across releases. Its notable trend signal lies at the intersection of two hot areas: agentic AI tooling and physical-world fabrication, making it a compelling bridge between LLM agents and real-world manufacturing pipelines. The multi-agent compatibility and agent-driven self-installation pattern reflect modern agentic UX design thinking, which likely contributes to its growing GitHub star traction.
ToolsMCPAppscodingworkflow-automationmultimodal
★ 21,502 total+2,141 this week
#56
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
★ 221,010 total+2,037 this week
#57NEWPartial week
**dsh-ops** is a JavaScript/TypeScript plugin for the DSH (DeepSeek Harness) platform that adds bounded file and document reading tools to AI agent workflows. It operates in two modes: Native mode, which returns compact, line-numbered text output, and PTC (typed Outcome) mode, backed by a Rust worker derived from the FastCtx project. The plugin provides 19 APIs covering file/document operations including CSV/TSV, DOCX, and limited PDF reading, with explicit exclusions for OCR, HTML scraping, and binary DOC formats. Seven components can be independently toggled without disrupting existing profile configurations, and an optional read-only TUI sidebar is available. Currently at **version 0.4.0 release candidate**, it targets a 40% token reduction over 0.3.x and enforces a 400-token cap on file/discovery schemas. Installation supports npm, official DSH CLI, and a Huawei Cloud npm mirror. The project is trending on Trendshift's JavaScript daily chart and ranked #2 on Upstar for JavaScript, suggesting rapid community growth. Licensed under MIT and Apache-2.0, it acknowledges FastCtx by yc-duan as its Rust tooling foundation.
ToolsAgentsMCPworkflow-automationlocal-first
★ 3,124 total+2,004 this week
#58
**Skills for Designers and Engineers** is a curated collection of AI agent "skills" created by Emil Kowalski, a designer/engineer with experience at Vercel and Linear, aimed at improving the quality of UI animations and interface design when using AI coding agents. The core premise is that AI agents lack taste — they make subtle but compounding mistakes like using wrong easing curves or poor visual choices — and these skills act as expert-encoded rules to correct that. Installed via a simple `npx skills@latest add emilkowalski/skills` command, the toolkit includes skills for building animations from scratch, reviewing and auditing existing animations, finding animation opportunities, applying Apple design principles, writing modern Swift, picking UI libraries, and working with Sonner (Emil's own toast library). It also covers React Native/Expo-specific animation guidance. The project is notably opinionated and experience-driven, explicitly positioning itself as a counter to generic AI output — a "shortcut to stand out in a sea of slop." Its trending status likely reflects growing developer interest in improving AI-assisted UI quality and Emil's strong reputation in the design-engineering community.
ToolsAppscodingworkflow-automation
★ 47,423 total+1,982 this week
#62
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, prominent websites across dozens of industries. The core concept originates from Google Stitch, which introduced DESIGN.md as a plain-text, markdown-based design system document that AI coding agents and design agents can read to generate visually consistent UI — no Figma exports, no JSON schemas, no special tooling required. The analogy is direct: just as AGENTS.md tells a coding agent how to build a project, DESIGN.md tells a design agent how the project should look and feel. The repository currently hosts 84 such files, each capturing deep design analysis including color tokens, typography rules, layout patterns, and visual language extracted from real production websites. The collection spans a wide range of categories: AI and LLM platforms (Claude, Mistral AI, xAI, ElevenLabs, Runway), developer tools and IDEs (Cursor, Vercel, Warp, Raycast), backend and DevOps tools (Supabase, Sentry, PostHog, MongoDB), productivity and SaaS (Linear, Notion, Intercom), fintech and crypto (Stripe, Coinbase, Revolut, Mercury), e-commerce (Shopify, Nike, Airbnb), and media and consumer tech (Apple, NVIDIA, IBM). Each entry includes a brief design personality description — for example, Stripe's "signature purple gradients, weight-300 elegance" or Ollama's "terminal-first, monochrome simplicity" — making the collection immediately useful for developers and "vibecoders" who want to replicate a specific aesthetic. Users can also request custom DESIGN.md files for specific websites via getdesign.md. The project is ranked #150 globally on GitHub, carries the official Awesome badge, and is actively maintained with recent commits. Its notable momentum likely stems from the explosive growth of AI-assisted UI development and vibe coding workflows, where LLM-readable design context dramatically improves output quality. It is community-oriented, sponsor-supported, and backed by VoltAgent's broader AI agent ecosystem including official MCP servers and a Discord community.
ToolsAppsMCPworkflow-automationcoding
★ 122,135 total+1,764 this week
#63
Nature Skills (Yuan1z0825/nature-skills) is an open-source, reusable scientific research skill library designed for AI-assisted academic workflows, targeting global scholars — with a particular emphasis on Chinese researchers. The project packages standardized, verifiable research workflows into modular "skills," each organized around a `SKILL.md` file and installable into multiple AI agent environments. The core philosophy is that practical research tools can be abstracted into reusable, machine-understandable skill units that AI agents like Codex or Claude Code can directly learn from and execute, eliminating the need for researchers to manually master every workflow. The project currently indexes 22 skills covering tasks such as Chinese-English paper reading (nature-reader), paper-to-PPT conversion (nature-paper2ppt), academic writing and polishing in Nature journal style (nature-polishing, nature-writing), pre-submission peer review simulation (nature-reviewer), reviewer response drafting (nature-response), scientific figure generation (nature-figure), literature citation analysis, patent conversion (nature-paper-to-patent), academic search (nature-academic-search), and research proposal writing (nature-proposal-writer). Installation is supported across multiple agent platforms — Claude Code, OpenAI Codex, OpenClaw, OpenCode, Hermes, and Chatbox — via an `npx skills` CLI, shell scripts, or direct git clone workflows. The repository includes auto-update mechanisms via `SessionStart` hooks for both Claude Code and Codex, allowing skills to stay current without manual intervention. A shared support package (`nature-shared`) provides common dependencies across skills, and optional Python/MCP dependencies support advanced features like PubMed search, CNIPA patent retrieval, and Playwright-based browser automation. The project is founded and maintained by Yuan Yizhe, with core development contributions from Ma Xinrui and Hu Bin. 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. A companion web platform at natureskills.cn offers browser-based access to Nature Polishing and Nature Figure features without local installation. Community engagement is maintained through Douyin video tutorials, a WeChat research group, and a Zhishi Xingqiu (knowledge community). The project is licensed under Apache-2.0 and is actively growing, making it notable as a pioneering, community-driven framework that is reshaping how Chinese and global researchers interact with AI agents for scientific work — particularly by enabling local computer control via agentic AI for end-to-end research tasks.
ToolsAppsAgentsworkflow-automationbrowser-usecoding
★ 49,159 total+1,695 this week
#64
The `skills` repository by Vercel Labs 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 and act as modular, reusable capability extensions that can be plugged into agents like OpenCode, Claude Code, Codex, Cursor, and over 75 others. The project is published on npm as the `skills` package and is licensed under MIT, positioning it as an open, community-driven standard rather than a proprietary solution.
The core command is `npx skills add`, which installs skills from a wide range of sources: GitHub shorthand (e.g., `owner/repo`), full GitHub or GitLab URLs, Azure DevOps repositories, arbitrary Git URLs, direct download links (supporting `.zip`, `.tar`, `.tar.gz`, `.tgz`, or raw `SKILL.md` files), and local paths. This flexibility makes it highly versatile for both public and private repository workflows. For private repositories, the CLI intelligently chains authentication strategies — Git credential helpers, GitHub CLI (`gh`), and SSH fallback — without ever exposing stored credentials to the Node.js process, which is a notable security-conscious design decision.
Installation can be scoped to a project (committed alongside code and shared with a team) or globally across all projects via the `-g` flag. Skills can be installed as symlinks (the recommended default, creating a single source of truth) or as independent copies when symlinks aren't supported. The CLI supports non-interactive, CI/CD-friendly usage through flags like `--yes` and `--all`, making it suitable for automated pipelines.
Beyond installation, the CLI offers a rich command surface: `skills list` to inspect installed skills, `skills find` for interactive or keyword-based discovery (including organization-wide searches), `skills update` to pull the latest versions of installed skills, `skills remove` to cleanly uninstall skills from specific agents or scopes, `skills use` to generate and pipe a skill's 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 ephemeral, one-shot agent interactions — it writes skill files to a temporary directory and either prints the prompt to stdout or launches a supported agent interactively.
The project is a Vercel Labs product, indicating it is experimental or early-stage but backed by Vercel's engineering organization. Its breadth of supported agents (79+), multi-platform source resolution, security-aware authentication handling, and clean CLI ergonomics suggest it is aiming to become a de facto package manager for the emerging AI agent tooling ecosystem — analogous to npm but for agent instruction sets. Its appearance on GitHub Trending reflects growing developer interest in standardized, portable AI agent capabilities and the broader trend of treating agent instructions as first-class, shareable software artifacts.
ToolsAgentsMCPcodingworkflow-automation
★ 35,525 total+1,673 this week
#68
Universal-modder is an open-source toolkit that equips any AI coding agent with the skills, tools, and a shared knowledge base needed to mod almost any PC game a user owns. Rather than targeting a single game or engine, it takes a universal approach: the agent automatically identifies the game, determines its engine, selects a modding route, reads actual game code, builds the mod, generates art, 3D assets, and sound via the fal AI platform, tests the mod in the running game, records a showcase video, and finally writes a structured "field note" to the shared knowledge base for future agents to build upon. This ten-step loop is codified in a skill called `mod-any-game`, which includes engine-specific playbooks covering Unity, Unreal, .NET/XNA (Terraria, Stardew Valley, Celeste), Godot, Source 1/2, Bethesda engines, Minecraft, the Genie engine (Age of Empires II), Bannerlord, RE Engine, GTA, Cyberpunk, Baldur's Gate 3, native C++, and many indie and retro engines. The project supports a wide range of AI agents out of the box — Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, and OpenCode — each receiving the same Agent Skills format, the fal MCP server, and the `um` CLI tool. A central and distinctive feature is the community-maintained `knowledge/` directory, a database of field notes written by AI agents for AI agents, documenting exact versions, modding routes, engine internals, verification steps, and known gotchas for specific games. Agents that complete a mod can automatically open a pull request to contribute their findings, creating a compounding, self-improving knowledge base. Additional skills cover game reconnaissance, web research (including Wayback Machine and Nexus/Workshop APIs), reverse engineering (ILSpy, Ghidra, Cheat Engine, Frida, RenderDoc), asset pipelines, game automation, showcase video production, mod porting, mashup mods (e.g., running Minecraft inside GTA V), and mod publishing. Asset generation is powered by fal for images, 3D, SFX, music, and video, with optional local ComfyUI and Sprixen support. The project is early-stage but actively growing, with a mod hub at universalmodder.com announced as coming soon and a Discord community already active. It is notable for its ambition to generalize AI-assisted game modding across virtually every PC game engine, its agent-agnostic design, and its novel AI-to-AI knowledge-sharing architecture. The Age of Empires II / Genie engine is explicitly listed as a supported engine playbook, making it directly relevant to that
ToolsAgentsAppsmultimodalcodingsynthetic-data
★ 8,368 total+1,639 this week
#70
**reverse-skill** is an open-source cybersecurity skills router designed to guide AI agents through structured, repeatable reverse-engineering and penetration-testing workflows rather than letting them guess commands. When an AI agent encounters a target — such as an Android APK, a native binary (ELF/DLL/EXE), obfuscated frontend JavaScript, a CTF challenge, firmware, or a pentest scope — the package routes it through a master routing ladder to the correct methodology, checks locally available tools, and executes a documented workflow covering evidence collection, timeline tracking, and report generation. The routing engine is driven by a single structured JSON configuration (`routing.json`) containing 44 rules (R0–R45), validated against a regression benchmark of 175 cases across Windows and Ubuntu CI platforms, keeping the core entirely client-neutral. The project supports over 20 distinct security scenarios, including APK/Android analysis, iOS mobile, binary reverse engineering, .NET/C#, JS encryption, DSL VM opcode analysis, malware/YARA, red-team attack chains, EDR bypass, LLM/AI security, supply chain/SBOM, API/GraphQL security, and CTF orchestration with 42 sub-skills. Key files include `MASTER-ROUTING.md` as the primary fast ladder, `RULES.md` as the global scope gate, `README_AI.md` as the AI agent bootstrap, and `skills/INDEX.md` as an auto-generated navigation index. Compatible AI clients include Claude Code, Codex, Cursor, and OpenCode, with all client-specific configuration kept optional and external. At version v1.0.1, the project is actively maintained with GitHub Actions CI, a supply-chain pin gate, and structured ops contracts. It is notably trending on Trendshift, sponsored by UCloud AstraFlow, Atlas Cloud, and Kite AI, and is notable for systematizing institutional security knowledge into a machine-consumable, agent-friendly routing framework that prevents repeated mistakes and tool confusion across diverse cybersecurity tasks.
ToolsAgentsMCPsecurityworkflow-automationcoding
★ 42,585 total+1,528 this week
#72
The **ai-memory** project is an open-source, self-hosted long-term memory system designed specifically for AI coding agents. Its core premise is elegantly practical: when you quit one AI coding assistant mid-task and open a different one in the same directory, you should not have to re-explain your architecture, your failed approaches, or your open questions. The tool acts as a shared, persistent memory layer that sits beneath any agent harness, allowing seamless continuity across tools, machines, and even teammates.
The project's most distinctive architectural decision is its choice of a **git-backed markdown wiki as the source of truth**. Memory is stored as ordinary `.md` files that users can grep, open in Obsidian, edit by hand, or sync with rsync. A derived database index is built on top of these files for retrieval purposes, but the index is always rebuildable from the source files. There is no vector store to maintain and no content locked in a proprietary binary format. This philosophy of user ownership and transparency runs throughout the entire design.
A standout feature is its **zero-LLM-by-default** operation. Capture, full-text search, entity search, graph traversal, handoffs, and even memory aging all work without any API key or LLM call. Optional LLM-powered features — such as a background "dream" consolidation pass that rewrites cold note clusters into coherent pages while the user is idle — exist but are explicitly opt-in and off by default. The dream pass also cancels immediately when the user returns to work and never hard-deletes source material, keeping pre-merge versions reachable through git history.
The **cross-agent handoff protocol** is a typed, claim-once mechanism: a handoff has an owner and can be claimed exactly once by the next agent. This prevents duplicate work and ensures clean baton-passing between tools like Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Grok, Devin, Kimi, Kiro, and more than twenty other harnesses, all of which are first-party integrations verified by CI. The support matrix is remarkably broad, covering Linux, macOS, NixOS, Windows via WSL2, and experimentally native Windows.
Memory capture happens silently through **lifecycle hooks** that observe prompts, tool calls, and session boundaries. At session end, observations are sanitized at a typed privacy boundary before anything is stored, then consolidated into readable wiki pages. The next session — on any agent, any machine — receives a bounded startup brief and can search the full knowledge base using fused ranking across full-text search, entity search, link graphs, and optionally local vectors.
The **cross-project profile** feature is particularly thoughtful: a small profile of a user's working habits (preferred package manager, test layout, architectural patterns) is automatically injected at the start of every new repository session, eliminating the repetitive re-explanation problem that plagues developers who work across many codebases. On a shared server this profile is opt-in and private per person.
Memory aging is handled without LLM calls through a configurable per-tier decay schedule with **access-weighted retention**: memory that is actively used (opened, searched, or reached through links) decays more slowly. Cold episodic notes can be compacted down to durable facts rather than dropped outright. Near-duplicates are collapsed, and likely contradictions are flagged. All destructive operations (compaction, dedup, per-tier decay curves) are off by default, and nothing is hard-deleted — the original always remains in git with a full version chain, and a `restore-page` command brings back any prior state.
The project ships as a **single self-contained Rust binary** (requiring Rust 1.95+), licensed under MIT, with an optional server-rendered management console for user administration, session inspection, and personal MCP API keys. An audit log records every mutation. The write ceiling of approximately 700 operations per second is measured empirically rather than estimated. Multi-user authentication, per-person attribution, and the audit log are built-in features, not reserved for a paid tier.
In terms of maturity, the project is actively developed with versioned releases tracked on GitHub, a dedicated website at aimemory.sh, and comprehensive documentation including architecture docs, a support matrix, a comparison guide, and cross-project profile documentation. It explicitly acknowledges its intellectual debts to projects like the Karpathy LLM Wiki, agentmemory, basic-memory, cognee, Hermes Agent, and the A-MEM paper on Zettelkasten-style atomic notes.
Its trending appeal likely stems from the explosion of
ToolsAgentsMCPcodinglocal-firstworkflow-automation
★ 10,647 total+1,501 this week
#73
`/brag` is an open-source agent skill that automatically transforms any software project into a short, shareable launch video — complete with music, motion, and social share copy — using a single command. It integrates with multiple AI coding agents (Claude Code, Codex CLI, opencode, Cursor, Copilot, Gemini CLI) via a standardized skill discovery system, making it broadly compatible without extra configuration. The core workflow has `/brag` autonomously determine the product angle and tone, then hand a focused brief to Hyperframes, which renders the final MP4. A leaner variant, `/brag-slim`, was recently introduced specifically for Claude Opus 5.5, dropping the Hyperframes dependency while preserving the creative output. Users can also skip local setup entirely via the hosted web app at letsbrag.app. The project is actively evolving — version 0.4.0 bundled `/brag-slim`, and the repo includes a benchmark suite of fake product sites for testing. Its novelty lies in treating video launch marketing as an automatable agent skill, lowering the barrier for indie developers to ship polished product announcements. It is free, open source, and welcoming contributions.
ToolsAppsvideoworkflow-automationmultimodal
★ 16,764 total+1,492 this week
#78
The **Academic Research Skills (ARS)** repository by Imbad0202 is a comprehensive plugin suite designed for **Claude Code**, Anthropic's AI coding assistant, that supports the full academic research pipeline — from initial planning and literature review through writing, citation management, integrity checking, and final publication-ready output. The project is currently at version **v3.23.1**, carries a DOI via Zenodo, and is licensed under CC BY-NC 4.0, signaling both academic legitimacy and active versioning maturity. It supports installation in under 30 seconds via a plugin marketplace command and is compatible with Claude Code CLI, VS Code, and JetBrains environments running v3.7.0 or later.
The core philosophy of ARS is **human-in-the-loop augmentation**, explicitly rejecting full automation. The tool positions AI as a "copilot, not the pilot," handling grunt work like reference hunting, citation formatting, data verification, and logical consistency checking, while requiring human confirmation at every pipeline stage. This design stance is directly motivated by a growing body of empirical and survey literature on AI research failure modes. The project cites **Lu et al. (2026, Nature)** on *The AI Scientist* — the first fully autonomous AI system to publish through blind peer review — whose limitations section catalogs hallucinated results, methodology fabrication, citation hallucinations, and frame-lock as endemic risks of full automation. ARS's architecture responds with Stage 2.5 and Stage 4.5 integrity gates running a 7-mode blocking checklist.
Citation integrity is a major technical focus. **Zhao et al. (2026)** audited 111 million references across 2.5 million papers on arXiv, bioRxiv, SSRN, and PMC, estimating 146,932 hallucinated citations for 2025 alone, with an inflection point in mid-2024. ARS responded across multiple versions: v3.7.1 added trust-chain frontmatter for source provenance; v3.7.3 added three-layer citation locator anchors; and v3.8 introduced an opt-in audit pass (`ARS_CLAIM_AUDIT=1`) that fetches cited sources against anchors and judges claim support. Five new HIGH-WARN classes — including claim-not-supported, fabricated-reference, and anchorless — gate-refuse output through a formatter terminal hard gate. A calibration runner ships with a 25-tuple synthetic gold set and FNR/FPR acceptance thresholds of under 0.15 and 0.10 respectively.
The project's design rationale is further anchored by **Ren et al. (2026)**, a survey of self-improvement in agentic systems, which concludes that discovery agents cannot reliably verify novelty, correctness, or reproducibility, and that human auditing remains a practical safeguard. ARS explicitly cites EURISKO's historical dependence on human evaluation signals as a persistent lesson for modern agentic systems. **Gartenberg et al. (2026, Organization Science)** provides a journal-side anchor: an AI Task Force analysis of 6,957 manuscripts and 10,389 reviews found that heavily AI-written submissions read worse on readability indices and were desk-rejected more often, with editors warning of a "more rather than better" equilibrium. ARS cites this as rationale for recording volume as a non-goal and for implementing a Collaboration Depth Observer and claim-strength ladder.
**Wang, Li et al. (2026)** supply a fifth anchor through a survey of 230 sources on the AI paper-review arms race, treating research production and peer review as a coupled system. Their finding — that AI-assisted teams in a PNAS randomized study (Brodeur et al., 2026) reproduced 91% of results versus 37% for AI-led teams — reinforces ARS's commitment to human-led verification at every checkpoint. ARS also draws inspiration from **PaperOrchestra (Song et al., 2026, Google)** for features including Semantic Scholar API verification, anti-leakage protocol, VLM figure verification, and revision-trajectory tracking.
Key features include a Socratic dialogue planner (`/ars-plan`), literature review generation (`/ars-lit-review`), Style Calibration that learns a user's voice from past work, Writing Quality Check to catch machine-generated prose patterns, cross-model verification via `ARS_CROSS_MODEL`, and output in Markdown, DOCX (via Pandoc), and APA 7.0 PDF (via tectonic). The full architecture is documented in `docs/ARCHITECTURE.md`, with a stage-by-stage matrix, skill dependency graph, and quality gate descriptions. The project is multilingual in documentation, offering READMEs in Simplified
ToolsAppsAgentsworkflow-automationsynthetic-data
★ 52,823 total+1,433 this week
#79
Geo-sleuth is an open-source agent skill that determines the precise geographic location where a photo was taken, even when the image contains no GPS metadata, readable text, license plates, or recognizable landmarks. The project is authored by Oldcircle and hosted on GitHub, and it operates as a standard Agent Skill — meaning it consists of a `SKILL.md` specification file plus a collection of plain Python scripts that any compatible AI coding agent can read and execute. The skill is compatible with Claude Code, OpenAI Codex, Cursor, Gemini CLI, OpenCode, and GitHub Copilot, as well as any other agent that reads `SKILL.md` and can run shell commands. Installation is straightforward via `npx skills add Oldcircle/geo-sleuth`, after which the user simply hands the agent a photo and says "find where this photo was taken."
The core philosophy of geo-sleuth is geometry over guesswork. Rather than relying on visual fame or population heuristics, the skill uses OpenStreetMap geometry, digital elevation data, satellite imagery tiles, and street-view data to conduct a structured, evidence-driven search. Every conclusion the agent reaches must be traceable to a specific script that ran and a specific file it produced during the session — population and fame are explicitly excluded as evidence. The workflow is divided between approximately twenty single-purpose Python scripts that search, score, and sort candidates, while the language model only selects among the top few results, keeping the model's role as a judge rather than a guesser.
Outputs always include coordinates with an explicit error radius, the camera heading, a satellite evidence image, and a graded confidence level, making results auditable and reproducible. The README documents three detailed case studies that demonstrate the skill's capabilities on photos with no GPS data. In the first case — a rice paddy and viaduct in Qingyuan, Guangdong, China — the skill narrowed 27,335 OpenStreetMap railway bridge segments down to a single camera position accurate to within ±2 meters, using catenary mast identification, pier spacing as a geometric ruler, skyline ridge-line matching against elevation data, and bearing triangulation from 17 individual piers. The process took roughly 72 minutes end to end.
The second case involved a desert skyline in Da Qaidam, Qinghai, China, where the only man-made objects were power pylons. The skill queried every power line across four provinces — Xinjiang, Gansu, Ningxia, and Qinghai — using `osm.py` and `terrain.py`, scanned 1,537 candidate sites, and ultimately resolved a 1-degree phone tilt that was causing the skyline fit to stall, eventually locating the camera to within 100 meters of a specific sand dune. The third case placed a flowering cherry tree on a Vancouver, Canada street to within 3 meters, using municipal street-tree open data, shadow analysis, and street-view confirmation.
Each case includes a detailed reproduction guide listing the input image, any hints provided, key parameters, and checkpoints at each pipeline stage so that users can identify exactly where a different model or different decisions might diverge from the documented run. The README is careful to note that each case reflects one run by one specific model, and that different models may reach different results. The first case was solved by Claude Opus 5.0. The project requires Python 3.10 or higher and provides a `doctor.py` diagnostic script to verify that all dependencies and environment checks pass on first use. The repository is MIT-licensed, welcomes pull requests, and includes a Simplified Chinese translation of the README. Geo-sleuth is notable for its rigorous, transparent methodology, its cross-agent compatibility via the emerging Agent Skill standard, and its demonstration that sub-10-meter geolocation is achievable from a single image using only open data sources and geometric reasoning — without any proprietary geolocation APIs or training on location-labeled image datasets. Its trend relev
ToolsAppsAgentsvisionmultimodalcoding
★ 3,380 total+1,408 this week
#80
Monid is an open-source connector layer described as "OpenRouter for agent tools" — a unified aggregation platform giving AI agents access to 2,000+ tools across 72+ providers through a single base URL and API key. Providers span web search and scraping, people and company enrichment, social platforms, reviews, market data, and media generation. The core innovation is a declarative connector format: each provider and endpoint is defined in TypeScript using `defineProvider` and `defineEndpoint`, with Zod schemas for inputs, making connectors writable by coding agents themselves. A `discover` verb ranks the entire catalog per call by job fit, returning price, live health, and latency percentiles, so the best endpoint is chosen dynamically rather than hardcoded. Usage billing is metered per call and settled on the raw wire response before output mapping, meaning vendor errors and unresolved lookups cost nothing. The engine pipeline is identical across local, CI (fixture-replay, no network), and hosted execution, with credentials injected inside the transport layer. The repo is structured around connectors, engine, compiler, and shared contract modules, and runs on Deno 2.x. Maturity appears early but deliberate, with 188 replay tests, a hand-reviewed PR contribution process, and an Apify scaffolding tool. It is notable for making multi-provider AI agent tool access composable, cost-transparent, and agent-authorable — a compelling infrastructure play in the rapidly growing AI-agent ecosystem.
ToolsAgentsMCPworkflow-automationcoding
★ 5,130 total+1,403 this week
#84
OpenCodeReview is an AI-powered code review CLI tool originally developed as Alibaba Group's internal assistant, having served tens of thousands of developers and identified millions of defects over two years before being open-sourced. The tool 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 — going well beyond surface-level diff feedback by reading full file contents, searching the codebase, and inspecting related changed files for deeper context. A standout design philosophy is its hybrid "Deterministic Engineering × Agent" architecture: hard-coded engineering logic handles critical steps like precise file selection, smart file bundling, fine-grained rule matching, and external positioning/reflection modules, while the agent focuses on dynamic decision-making and context retrieval using scenario-tuned prompts and a purpose-built toolset distilled from large-scale production traces. Benchmarked against 50 popular open-source repositories, 200 real Pull Requests, 10 programming languages, and 1,505 annotated ground-truth issues validated by 80+ senior engineers, OpenCodeReview achieves significantly higher Precision and F1 than general-purpose agents like Claude Code using the same underlying model, while consuming only ~1/9 of the tokens. It supports delegation mode, where an AI coding agent performs the review itself with OpenCodeReview handling file selection and rule resolution — no LLM configuration required. The tool integrates with Claude Code, Codex, Cursor, Kimi Code, OpenCode, and QCA Forward, and is installable via npm, install script, or GitHub Release binary. It holds OpenSSF Gold badge status, indicating strong security and maturity practices, and is actively trending on Trendshift.
ToolsAgentsAppscodingsecurityworkflow-automation
★ 47,610 total+1,347 this week
#90
**i-have-adhd** is a coding assistant skill/plugin (designed for Claude Code) that reformats AI responses to be ADHD-friendly — leading with the direct action, numbering steps, and eliminating filler phrases like "Hope this helps!" or "Great question!" The project enforces 10 concise communication rules: action-first answers, numbered multi-step tasks, concrete next steps, suppressed tangents, restated context each turn, specific time estimates, visible wins, matter-of-fact error handling, capped lists (5 items max), and zero preamble or closers. Installation is unusually frictionless — users paste a single prompt into their CLI. The plugin is customizable via forking and editing a `SKILL.md` file. It is multilingual, with READMEs in 8 languages, suggesting broad international appeal. The project is early-stage but notably polished, and its trending appeal likely stems from growing neurodivergent-inclusive tooling interest and frustration with verbose LLM outputs. It is loosely inspired by the book *The Adult ADHD Tool Kit* by Ramsay and Rostain, adapted for LLM interaction patterns rather than human productivity habits.
ToolsAppscodingworkflow-automation
★ 57,728 total+1,209 this week
#91
Lemo-Opuscar is an open-source creative toolkit by Lemomo (lemomo-ai) that provides 51 distinct film styles, each accompanied by a fully code-generated short film, enabling users to direct AI-produced films by supplying their own story or topic. The project is explicitly built around Claude Opus 5.5 as its directing agent, with the README warning that other models may not reliably reproduce the styles. Every film produced through the system is generated entirely in code — no video generation tools or stock footage are used — with visuals rendered frame-by-frame via canvas and WebGL, original music sourced from free sample libraries, and narration produced through text-to-speech. The project is structured around three core guide files: DIRECTOR.md (covering story, rhythm, camera, and performance), TECHNIQUE.md (covering rendering, voice, and mixing), and per-style STYLE.md files that define the visual and sonic character of each style while leaving the story to the user.
The 51 styles span a wide creative range, organized into categories including Evidence Films, Hand-drawn and Painting, East Asian Traditions, and others. The Evidence Films category — added in an October 2026 update — is particularly notable, comprising 8 styles that ground every number and visual in real, sourced or measured data, covering subjects like LiDAR terrain surveys, satellite imagery, data physicalization, and archival light tables. A flagship showcase called OPUSCAR 98 demonstrates the system's ambition: a 6-minute 31-second film walking through all 98 Academy Award Best Picture winners, each rendered in a matching style, with 77 2D, 4 2.5D, and 17 3D styles represented, all written entirely by Claude Opus 5.5.
Usage is offered via two paths: installing a Claude plugin from the marketplace with a simple terminal command, or cloning the repository directly. Once set up, users simply describe their desired film in natural language, naming a style and topic. The agent asks a small number of clarifying questions upfront — about user-supplied assets and whether a storyboard preview is wanted — then autonomously produces the complete film, typically in 30 to 60 minutes. Prerequisites include Node 20+, ffmpeg, and Python 3.11+. Default output is 1920×1080 at 24 fps.
The project is notable for several reasons. It represents a sophisticated, production-oriented application of agent-driven creative coding, treating an LLM as a full film director rather than a simple code generator. The tight coupling to Claude Opus 5.5 and the explicit plugin marketplace integration signal a maturing ecosystem around Claude Code as a platform for agentic workflows. The bilingual README (English and Simplified Chinese) and the breadth of culturally diverse styles — from Chinese ink wash and shadow puppetry to ukiyo-e and impasto oil painting — suggest an intentionally global audience. The Evidence Films addition, with its emphasis on verifiable, sourced data embedded directly into generated visuals, points toward a trend of AI-generated content that prioritizes factual grounding. Licensed
ToolsAppsAgentsmultimodalvideocoding
★ 3,140 total+1,199 this week
#93
pstack-claude is a port of Lauren Tan's opinionated Cursor agent skill stack, adapted for Claude Code, Codex, Pi, GitHub Copilot, and other AI agent harnesses. Its central feature is `poteto-mode`, a routing layer that automatically selects the correct workflow for a given task — covering bugs, features, refactoring, performance, prototyping, PR maintenance, and longer projects. The stack emphasizes concise, simple, verified code, delegating work through sub-agents like `architect`, `arena`, and `swarm`, then validating with `interrogate`, tests, and measurements. Installation is supported across multiple CLI tools and shared skill directories (`~/.agents/skills/`), with per-harness configuration notes and a `setup-pstack` command for tuning model defaults and reasoning effort per role. For concurrency bugs and formal invariants, it integrates with a companion plugin, `agent-formal-verify`, adding TLA+ and Lean proof support. The project tracks upstream pstack and carries named policy forks declared in `tools/forks.json`. It has no telemetry or server component. Its cross-harness breadth and structured multi-agent orchestration make it notable as a practical, privacy-respecting productivity layer for AI-assisted development.
ToolsAgentsAppscodingworkflow-automationlocal-first
★ 2,998 total+1,171 this week
#94
The `marketingskills` repository by Corey Haines is a curated collection of AI agent skills — structured markdown files that give AI coding agents specialized marketing knowledge and workflows — designed for technical marketers and founders who want to automate or augment marketing tasks using AI agents. The project covers a remarkably broad surface area of modern digital marketing, including conversion rate optimization (CRO), SEO, AI-SEO, copywriting, cold email, paid ads, analytics, attribution, A/B testing, app store optimization (ASO), churn prevention, community marketing, influencer marketing, pricing, paywalls, lead magnets, free tools, product launches, go-to-market strategy, sales enablement, revenue operations, competitor research, directory submissions, email sequences, social media, video, SMS, image generation, co-marketing, events, and more — totaling over 40 distinct skills. The architecture is notably thoughtful: a central `product-marketing` skill acts as a shared foundation that every other skill reads first to understand product context, audience, and positioning before executing any task, and skills cross-reference each other in meaningful clusters (e.g., copywriting ↔ CRO ↔ A/B testing; RevOps ↔ sales enablement ↔ cold email; SEO audit ↔ schema ↔ AI-SEO). The library is compatible with major AI coding agent platforms including Claude Code, OpenAI Codex, Cursor, and Windsurf, and conforms to the Agent Skills spec at agentskills.io. It is MIT-licensed and free to use, with a transparent partner/sponsorship model where vetted tool integrations — currently Converly (server-side conversion tracking), Ploy (AI website and growth platform), and AIsa (aggregated SEO, search, and social data API) — fund ongoing development without influencing core skill recommendations. The project is actively maintained and open to community contributions via pull requests. It connects to a broader ecosystem built by Haines, including the Conversion Factory agency, the Swipe Files marketing newsletter, an AI Marketing Training course, a Coding for Marketers companion guide for non-technical users, and Magister, an autonomous AI marketing agent that uses these skills as its CMO-layer intelligence. The repository appears early-stage but architecturally mature, with a well-designed dependency graph, tooling for partner sync automation, and a guided setup workflow for connecting real marketing accounts. Its trending appeal likely stems from the intersection of the booming AI agent ecosystem and the practical, immediately deployable nature of the skills for a large audience of marketers seeking to leverage LLM-powered coding agents without deep engineering backgrounds.
ToolsAppsAgentsworkflow-automationcoding
★ 55,415 total+1,163 this week
#95NEWPartial week
new-term-radar is an open-source daily intelligence tool that detects emerging AI names — new models, products, tools, and repositories — at the earliest possible moment, before they appear in conventional keyword research platforms like Google Trends or SEO tools. The core insight driving the project is that a new AI term leaves a traceable trail across multiple public signals in a predictable sequence: first mentioned on X or appearing on Hugging Face's trending list, then a GitHub repo breaks out, then directories and competitors add pages, then search impressions begin, and only finally does Google Trends register the curve. Most keyword tools read only that last step; this radar reads steps one through four daily and uses step five purely for self-validation. The motivating example is the Strata repository by Niko1221, which was created on 2026-09-24 and accumulated 7,700 stars within nine days, with people already searching "niko strata" from September 26th while no keyword tool had listed it yet — a single repo gaining 800 stars per day being the entire, publicly available signal.
The system ingests eight distinct signals: X posts from a curated account list (detecting first-time name usage within 60 days), Hugging Face trending models and Spaces, GitHub breakout repositories (under 14 days old, averaging 200+ stars per day or +400 since yesterday), sitemap analysis across AI tool directories like Toolify, Futurepedia, and Aixploria, newly registered and indexed domains already ranking for 20+ keywords, Reddit "asks" (requests for AI tools phrased in twelve different ways), verified revenue data from TrustMRR for fast-growing products, and Google Search Console impressions for fresh queries on the user's own site. Each signal has different cost and dependency profiles, with GitHub and Hugging Face being free and X reads costing roughly $0.003 per account per run. A full monthly run with 35 X accounts and keyword tables for five names per day costs approximately $15.
A central feature is the keyword table, which pairs each detected name with the generic search terms representing the underlying job people are trying to accomplish. For example, "SynthID Detector" maps to "ai image detector" — a durable, unbranded term with real ongoing search volume. The table includes estimated daily searches, trend shape, peak timing, week-over-week momentum, and a page-one difficulty assessment. Page-one analysis checks Google's first-page results, rates each competing site, calculates keyword difficulty, and identifies whether the competitive landscape is open, crowded, or mixed. Optional GoAnyAPI integration adds Google Trends related queries, country-level (US) trend series, advertiser presence, and pages recently built around the term. Decisions are classified as prioritize, watch, or skip based on recency of rise, current momentum, and daily search volume thresholds.
Each name is read twice — on the day it appears and three days later — because announcement-day posts are mostly announcements with no usage signal yet. A 14-day review then checks each lead against Google Trends to measure hit rate and how many days ahead of mainstream tools the radar detected it. Special markers flag content type (video, voice, image) and highlight viral posts describing manual workflows that could become one-click tools. The project is in an early but actively developed state (versions 0.3 and 0.4 recently added revenue signals, Reddit asks, page-one checks, and formatting improvements), with honest c
ToolsRetrievalMCPworkflow-automationsynthetic-data
★ 1,112 total+1,127 this week
#99
**video-shotcraft** is an agent-driven promotional video creation skill for AI coding agents (Claude Code and Codex) that transforms product screenshots and copy into polished, fully editable MP4 films — without relying on generative video models. Instead, every frame is rendered programmatically using Remotion (a React-based video framework), ensuring sharp, on-brand, and fully editable output. The workflow is end-to-end: the agent captures real product pages, selects motion recipes from a curated shot library, storyboards the film, animates it, syncs cuts to a beat, adds sound design, performs frame-level QA, and delivers a finished 1920×1080 MP4 alongside the full Remotion source project. The shot library is a standout feature, comprising 124 recipe cards across 10 categories (Opening & Brand, Camera, Transitions, Typography, UI Entrance, Interaction, Data, Light & Emphasis, Rhythm, and Outro) totaling 150 named shots — all browsable in a live Gallery. Each shot card is a documented Markdown file with a corresponding Remotion demo implementation. After delivery, the skill opens **Motion Workbench**, a CapCut-style browser editor where users can edit copy, retime clips, swap shots from the library, and re-export — with frame-identical preview and render. The project also supports **JianYing (CapCut CN) export**, producing editable drafts with per-shot clips, caption tracks, and separate audio tracks, verified on JianYing Pro 11.2 for macOS. Optional social publishing via Upload-Post supports TikTok, Instagram, YouTube, LinkedIn, and X. A sibling project, **video-talkcraft**, handles narration-driven videos with voiceover-locked motion beats. The repo ships with 149 SFX files, 5 BGM tracks, reusable Remotion components (2.5D camera, captions, digit rolls), and page-capture scripts. Installation is straightforward via a natural-language agent prompt, the `skills` CLI, or manual symlinking. The project is actively maintained with a 2026-10 shot library refresh, is trending on Trendshift, and is sponsored by APIMart, PackyCode, and AWS — signaling meaningful community traction and commercial interest. Its agent-native design, code-first rendering philosophy, and rich shot library make it a notable
ToolsAppsvideomultimodalworkflow-automation
★ 12,424 total+1,087 this week
#107
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. The core idea is to help developers — especially those onboarding to large, unfamiliar projects — quickly grasp how every file, function, class, and dependency fits together, rather than reading code blindly. The tool operates as a plugin natively for Claude Code and is also installable via a one-line shell script across a wide range of AI coding platforms including Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode, Vibe CLI, Trae, Cline, Kiro, Nanobot, and more. At its heart, a multi-agent pipeline scans the project, extracts structural relationships, and saves the result as a knowledge graph JSON file, which is then rendered as a color-coded, interactive web dashboard users can pan, zoom, search, and click through. 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 changes, persona-adaptive UI that adjusts detail level for junior developers, PMs, or power users, and automatic layer visualization grouping nodes by API, Service, Data, UI, and Utility layers. The tool also supports domain-level views that map code to real business processes and flows, and can analyze Karpathy-pattern LLM wikis by extracting wikilinks, categories, and implicit relationships to produce force-directed knowledge graphs with community clustering. Localization is a notable feature, with support for generating node summaries, dashboard labels, and guided tour content in English, Simplified Chinese, Traditional Chinese, Japanese, Korean, Russian, and Vietnamese. Incremental re-analysis means only changed files are re-processed after the initial run, keeping token costs manageable. The project explicitly supports privacy-conscious or enterprise setups by allowing users to point the tool at local model providers like Ollama. The repository is trending on Trendshift (ranked #23482), carries an MIT license, and includes a live demo on its homepage. The project's philosophy — "AI should help people, not replace them" — positions it as a human-augmentation tool rather than an automation replacement, which may contribute to its broad appeal and growing momentum across the AI developer tooling ecosystem.
ToolsRetrievalAppscodinglocal-firstvector-database
★ 86,914 total+969 this week
#111
The `logo-design-skill` repository by kaankiziltug is a comprehensive, production-ready agent skill that transforms Claude — and any other AI agent supporting the open Agent Skills format, such as Gemini CLI, Codex CLI, Cursor, or GitHub Copilot — into a disciplined, professional identity designer. The skill guides the agent through the full logo design lifecycle: from initial discovery and brief-taking, through word mapping, mark-type selection, concepting, geometric construction, optical corrections (overshoot, bone effect, irradiation), colour theory, typography, lockup creation, testing, client presentation, and final delivery of production-ready SVG files and brand guidelines. A defining structural feature is a mandatory human-in-the-loop checkpoint: the agent always stops after generating 8–12 concept one-liners and building three SVG concepts, presenting them as a single overview image with a recommendation before proceeding. Nothing further is produced until the user selects a direction, ensuring the expensive kit-building phase (colour lockups, mockup boards, favicon/icon sets, guidelines) only happens for an approved idea. This checkpoint-first philosophy is explicitly demonstrated across 28 fictional brand examples spanning sectors from specialty coffee and luxury fashion to SaaS, fintech, telehealth, and urban mobility, with several cases where the client deliberately chose a different concept than the skill recommended — illustrating the workflow's flexibility. The repository includes a reference library of over 1,400 real-world SVG logos, each visually classified by mark type, technique, geometry, subject, typography, mood, and industry. This library is searchable from the command line and browsable in a local gallery, used to study construction conventions and avoid look-alikes rather than to copy. A suite of dependency-free Python tools handles SVG auditing against logo principles, concept overview sheet generation, multi-test sheet creation (16px pixel test, one-colour, reversed, squint, mirror, contexts, competitor shelf test), client presentation board creation with industry-specific mockups, PNG rendering, and complete favicon/app-icon/web-manifest export. The skill uses the open Agent Skills format — a folder with a `SKILL.md` and plain Python tools — making it portable across Claude Code (via plugin marketplace or manual install), Claude.ai, Claude Desktop, Gemini CLI, Codex CLI, Cursor, GitHub Copilot, and OpenCode. Installation is straightforward across all platforms, with a lite version available for upload size constraints. The project carries a CI badge for automated tests and is ranked #14 on The New 100 agentic leaderboard, signaling active community recognition and early traction. Its notable qualities include the disciplined process encoding of real-world brand identity methodology, the large classified SVG reference library, the zero-dependency tooling philosophy, and broad multi-agent compatibility. The 28 richly documented example runs — covering vivid palettes, crowded categories like SaaS and fintech with explicit cliché avoidance rules, and honest risk flagging — demonstrate both depth and practical maturity. This project is trending in the agent-skills space as AI coding assistants increasingly support pluggable skill formats, and logo/brand design represents a high-value creative domain where structured process guidance meaningfully improves AI output quality.
ToolsAppsmultimodalworkflow-automationcoding
★ 3,703 total+914 this week
#112
RTK (Rust Token Killer) is an agent-agnostic token optimization tool that intercepts shell command outputs and compresses them before they reach an AI agent's LLM context window. Built as a single Rust binary with under 10ms overhead, RTK supports over 100 shell commands and can reduce bash output by up to 90%, making agentic coding workflows significantly cheaper and faster. The core idea is straightforward: rather than letting verbose raw command output flood an agent's context, RTK sits in the pipeline and applies four 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). For example, `git log` output is reduced to hash, author, and subject only; `cargo test` and `pytest` show failures only with passing tests collapsed to a count; and `ls`/`tree` outputs are reformatted with file counts instead of one line per entry. RTK integrates with 18 AI coding tools including Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex, Windsurf, Cline/Roo Code, OpenCode, Kilo Code, Kimi AI, Factory Droid, Trae, Mistral Vibe, Google Antigravity, Pi, Oh My Pi, Hermes, and OpenClaw. Installation is handled via Homebrew, winget, or a curl script, and per-agent setup is done with a single `rtk init` command. RTK ships in three distinct packages: the full `rtk` binary (Apache-2.0 + BUSL-1.1) with hooks, filters, and the compression engine; `rtk-oss` (Apache-2.0 only) with hooks and filters but no engine; and `rtk-proxy` (BUSL-1.1), a daemon that compresses API traffic. Production use is free across all editions, but using RTK as a commercial product or service offered to third parties requires a separate license. The project is transparent about how savings are measured — token counts are estimated as bytes divided by 4, making percentages reliable but absolute numbers approximate, and bash output is only one contributor to total LLM input tokens. RTK explicitly notes it does not break Claude's prompt cache, since filtered outputs are stored in history and cached normally on subsequent API calls. The README is multilingual, available in English, French, Chinese, Japanese, Korean, Spanish, and Portuguese, signaling broad international adoption ambitions. The project appears to be actively trending on GitHub, with a star history rank badge
ToolsServingAgentscodingworkflow-automationlocal-first
★ 83,898 total+908 this week
#113
agent-memory is an open-source long-term memory runtime for AI agents, designed to solve the fundamental problem of session amnesia — the fact that agents forget everything they learned once a conversation ends. At version 0.1.0 and requiring Python 3.12+, it is an early-stage but architecturally thoughtful project from tigerless-labs that targets any agent capable of running a shell command, not just coding assistants. Its core philosophy is that Markdown files on disk are the single source of truth, while a SQLite-backed index is merely a rebuildable cache — meaning you can delete the entire index directory and run `mem rebuild` without losing a single memory, a guarantee enforced by automated tests rather than documentation promises.
The project's central architectural insight is the synthesis of two historically separate approaches to agent memory. One approach builds retrieval engines with embeddings and knowledge graphs that are powerful but opaque and vendor-locked. The other hands agents a plain filesystem that is legible and portable but does not rank results and breaks down at scale. agent-memory merges both: a local retrieval engine indexes a filesystem the agent can also browse directly with `ls` and `grep`. Relations live as links inside Markdown frontmatter, a local BM25 index over FTS5 ranks results, and an optional vector plugin can be fused in via Reciprocal Rank Fusion. Crucially, nothing in the read path calls a model or crosses a network, and zero API keys are required.
Retrieval is designed around a tiered depth model. Rather than pasting text into context, recall returns an L0 list of one-line abstracts with file paths, anchors, and scores. The agent then opens individual memories at the depth the task demands — abstract, outline, full file, or raw traced messages — with each rung costing roughly an order of magnitude more context than the last. This prevents unnecessary context bloat while preserving full access when needed.
Writes are handled automatically at conversation boundaries rather than relying on the agent to remember to save things. A separate sleep-time consolidation pass then runs on its own clock, performing consolidation and forgetting by value. Deletions from this unattended pass arrive only as proposals requiring human confirmation, preserving safety. The supersede mechanism keeps the full chain of memory versions intact, and `recall --as-of` allows querying the store as it existed at any past date, so updating never destroys history.
The system supports three hosts natively — Claude Code, Codex CLI, and Muse Code — and provides a `mem setup` command that probes the host, initializes the store, installs lifecycle hooks, and runs preflight checks, ending with a `status: READY` confirmation. A `mem doctor` command provides layered diagnostics distinguishing host, config, store, hook, and reasoner failures. An MCP server (`mem-mcp`) is also available for agents that speak the Model Context Protocol, exposing core operations like recall, read, record, correct, supersede, merge, and delete.
Empirical validation is provided via a bounded LongMemEval-S benchmark using 120 episodes, with Claude Haiku 4.5 as the host agent and Sonnet 5 as judge. agent-memory achieved 52.9% pooled accuracy versus 35.8% for MemCore and 5.8% for no-memory baseline, with statistically significant pairwise differences. Cross-host compatibility was also validated:
ToolsRetrievalMCPlocal-firstvector-databasecoding
★ 4,290 total+891 this week
#121NEWPartial week
Jevgrep (`jg`) is a CLI tool that helps coding agents find relevant source code by asking natural-language questions about a repository, returning file locations, reading leads, and verbatim source excerpts in a single stdout response. It uses Jev, Vercel's AI Gateway model, to judge relevance across folders, files, and declarations, supporting Python, TypeScript/JavaScript, Go, and Rust with declaration parsing. Its headline claim is ~30% lower coding-agent cost: benchmarked on ten SWE-bench tasks, it matched the baseline's 8/10 task success rate while reducing Sol-only cost from $7.62 to $5.44 (28.6%). A subsequent v0.4.3 total-cost rerun showed 25.8% savings including Jev costs, and v0.5.0 cut native Jev cost ~59% further. The tool integrates with agents like Claude Code, Codex, and OpenCode via an installable skill system, and supports providers including Vercel AI Gateway, OpenRouter, and TypeSafe-compatible endpoints. Built with TypeScript, Bun workspaces, and Turborepo, it requires only Node.js 22+ with no Python or ripgrep dependency. It is actively versioned with published evaluation methodology, making it notable for transparent cost benchmarking in the AI coding-agent space.
ToolsRetrievalAgentscodingworkflow-automation
★ 2,795 total+849 this week
#122
Headroom is an open-source context compression layer designed specifically for AI agents and LLM-powered applications. Built by Headroom Labs AI, the project addresses one of the most pressing practical problems in agentic AI workflows: runaway token consumption. When agents process tool outputs, logs, RAG chunks, files, and conversation history, context windows fill rapidly and costs escalate. Headroom intercepts all of that content before it reaches the LLM, compresses it intelligently, and forwards only the reduced payload — delivering the same answers at a fraction of the token cost. Critically, all compression runs locally on the user's machine, meaning no prompt content or file data is transmitted to any external compression service.
The project offers four distinct integration modes to fit virtually any stack. First, a Python and TypeScript library exposes a simple `compress(messages)` call that can be dropped inline into any application. Second, a drop-in proxy (`headroom proxy --port 8787`) requires zero code changes and works with any language or framework. Third, an agent-wrap command (`headroom wrap`) supports a wide range of popular coding agents including Claude Code, Codex, Grok, Copilot, Cursor, Aider, Cline, Continue, Goose, OpenHands, and others, with a corresponding `headroom unwrap` to reverse the change. Fourth, an MCP server exposes `headroom_compress`, `headroom_retrieve`, and `headroom_stats` tools for any MCP-compatible client.
Architecturally, Headroom routes content through a pipeline consisting of a ContentRouter that detects content type, then dispatches to one of three specialized compressors: SmartCrusher for JSON, CodeCompressor using AST-based analysis for source code, and Kompress-v2-base — a custom model hosted on Hugging Face — for prose and general text. A CacheAligner component identifies volatile content that would break provider KV-cache prefixes without rewriting prompts, and a CCR (Compressed Content Retrieval) system caches originals locally so the model can fetch full text on demand via `headroom_retrieve`.
Benchmark results across four real-world scenarios are compelling. An SRE incident debugging scenario compressed 55,957 tokens down to 24,340 — a 57% reduction — while preserving a critical FATAL log line byte-for-byte. A codebase exploration scenario achieved 42% reduction, GitHub issue triage 30%, and code search 21%. Compression latency is negligible: 0.21 ms at the p50 for a 10K-token JSON payload and 1.4 ms at 100K tokens. Accuracy evaluations show no degradation on GSM8K math benchmarks, no detectable change on TruthfulQA, 97% accuracy on SQuAD v2 at 19% compression, and 97% on BFCL tool-use benchmarks at 32% compression.
Beyond input compression, Headroom also targets output token reduction — significant because output tokens on Opus-class models cost roughly 5× input tokens. Two mechanisms handle this: verbosity steering, which appends a terse-response instruction to the tail of the system prompt to preserve cache hits, and effort routing, which dials down reasoning effort for low-stakes turns like file reads or passing tests while preserving full effort for new questions and errors. These features work across both Anthropic and OpenAI-compatible endpoints and are toggled via `HEADROOM_OUTPUT_SHAPER=1`.
A `headroom learn` feature mines past agent sessions to extract failure patterns and write corrections into agent instruction files such as `CLAUDE.local.md`, `CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, or `GROK.md`. A `--verbosity` flag additionally infers preferred answer length from past interaction patterns. Cross
ToolsRetrievalMCPlocal-firstworkflow-automationcoding
★ 75,923 total+838 this week
#123
gstack is an open-source "software factory" created by Garry Tan, President and CEO of Y Combinator, that transforms Claude Code (and other AI coding agents) into a virtual engineering team of specialized roles. The project is framed as Tan's personal answer to the question of how a single builder can now ship like a team of twenty, inspired by observations from Andrej Karpathy about writing almost no code by hand and by Peter Steinberger's solo-built OpenClaw project. Tan positions gstack as the tooling behind his own dramatically accelerated output: he claims three production services and over 40 shipped features in 60 days while running YC full-time, with a 2026 "logical code change" run rate roughly 810× his 2013 pace—numbers he backs with a documented methodology addressing the controversy over AI-inflated raw line counts. The repository emphasizes that the point is not who typed the code but what shipped, and that AI wrote most of it.
Functionally, gstack provides twenty-three specialist roles and eight power tools, all implemented as slash commands written in Markdown, distributed free under the MIT license. The roles mimic an engineering organization: a CEO who rethinks the product, an engineering manager who locks architecture, a designer who catches AI "slop," a reviewer who finds production bugs, a QA lead who opens a real browser, a security officer who runs OWASP and STRIDE audits, and a release engineer who ships the pull request. Key slash commands include /office-hours (product interrogation with forcing questions), /plan-ceo-review and /autoplan (strategic planning), /review (rigorous code review), /qa (browser and API testing), /cso (security auditing), and /ship (release automation). The intended audience is founders and CEOs who still want to ship, first-time Claude Code users wanting structured roles instead of a blank prompt, and tech leads or staff engineers seeking automated review, QA, and release rigor on every PR.
Installation is designed to be fast—about 30 seconds after cloning on a 4-vCPU Linux machine—and is driven by pasting a prompt into Claude Code that clones the repo into the skills directory and runs ./setup. Requirements include Claude Code, Git, and Bun v1.4.2+ (setup refuses versions older than 1.3.3 for security reasons related to reading a project's .env), plus Node.js on Windows. On macOS, the Aside browser is recommended so browser skills, /make-pdf, and /diagram can drive real logged-in sessions; otherwise gstack builds its own bundled Chromium browser. The /cso security tool additionally needs a Bun release with specific build flags and a native toolchain (a static-capable C compiler on Linux, Xcode command-line tools on macOS, or Visual Studio 2022 Build Tools on Windows); when absent, /cso reports "not assessed." Setup also supports preloading CSO runtime Docker images with configurable timeouts and resumable, digest-based progress.
gstack offers a "team mode" via ./setup --team and gstack-team-init that bootstraps shared repositories so teammates automatically receive gstack without vendored files or version drift, with per-session auto-update checks throttled to once per hour and network-failure-safe. Teams can require or merely nudge adoption. The project integrates deeply with OpenClaw, which spawns Claude Code sessions via ACP so gstack skills work automatically; natural-language requests to an OpenClaw agent map to gstack workflows like security audits, feature builds, and planning. Four native OpenClaw methodology skills (office-hours, ceo-review, investigate, retro) are installable directly through ClawHub and run conversationally without a Claude Code session. Beyond Claude, gstack supports many agents via ./setup --host, including OpenAI Codex CLI, OpenCode, Cursor, Factory Droid, Kiro, and GitHub Copilot CLI, with --host auto detecting and installing for all present agents. Agents are classified into tiers—full (certified by a real workflow run), experimental (passes conformance tests but uncertified), and inst
ToolsAgentsAppscodingworkflow-automationsecurity
★ 136,877 total+833 this week
#124
Codex Auth Helper (Codex 认证助手) is a lightweight Chrome extension (Manifest V3) designed specifically for Codex developers to securely manage and export ChatGPT session credentials as a local `auth.json` configuration file. The extension automatically detects the current browser's ChatGPT login state, displaying user avatar, email, and subscription plan (Free/Plus/Pro), while providing a real-time countdown of token expiry. A standout feature is its automated JWT synthetic token construction, generating a Codex-compliant `id_token` for seamless authentication. All processing is strictly local — credentials are never uploaded to any third-party server, with downloads triggered via `data:` URLs to avoid memory leaks. The UI features a polished Glassmorphism design with smooth transitions and toast notifications. At version 1.0.0, the project is early-stage but functional, requiring only developer-mode sideloading. It is notable for its strong privacy stance, minimal permissions (`downloads` and `chatgpt.com` only), and zero external CDN dependencies, making it relevant to developers working with OpenAI's Codex in environments requiring local auth configuration.
ToolsAppsSafetylocal-firstsecuritybrowser-use
★ 19,223 total+811 this week