Ponytail is a skill ecosystem for AI coding agents that enforces a 'lazy senior developer' mindset through a priority ladder: YAGNI, reuse existing code, prefer stdlib/native features, avoid unrequested abstractions, and write minimal working code. It delivers this via platform-specific adapters (hooks, command files, plugin manifests) for agents like Claude Code, Codex, GitHub Copilot, OpenCode, Gemini CLI, and others. The core skill definition lives in skills/ponytail/SKILL.md, with companion skills for review, audit, debt tracking, gain scoring, and help. The system includes automated validation scripts to maintain consistency across platform-specific rule copies and version manifests, benchmark suites to measure code/token/cost reductions, and test coverage for hook behavior and plugin integrity.
OpenMontage is an open-source, agentic video production platform where an AI coding assistant (Claude Code, Cursor) orchestrates the entire pipeline. It provides a library of 100+ tools (video generation, audio, graphics, enhancement, analysis, avatar, subtitles) behind a scored provider selection layer, and 10+ production pipeline manifests (animated explainer, cinematic, documentary montage, talking head, etc.) that define stage order, approval gates, and tool assignments. The core architecture is a Python framework with a BaseTool class, ToolRegistry for auto-discovery, pipeline loader, checkpoint system, and a Remotion-based video composer. It also includes a Backlot living storyboard server for live production monitoring and an Ink Theater procedural puppetry engine. While primarily an application, it contains data/research elements such as ManimGL/ManimCE educational animation examples covering transformer internals, quantum mechanics, and ML concepts, as well as a CLIP-based corpus builder for documentary montage pipelines.
drawio-skill is a comprehensive toolkit for generating, manipulating, validating, and publishing draw.io architecture diagrams from natural language, codebases, infrastructure-as-code, API specifications, and other structured sources. It provides a unified CLI (`diagramctl.py`) and an optional MCP server (`diagramctl_mcp.py`) that expose workflows for building, syncing, viewing, testing, reviewing, querying, what-if analysis, story generation, and publishing diagrams. The system uses a formal Diagram Intermediate Representation (IR) to separate semantic meaning from geometry, enabling incremental reconciliation, multi-view projection, architecture contract enforcement, and accessible HTML story output. It includes 15+ importers for languages (Python, JS, Go, Rust), IaC (Terraform, Kubernetes, Docker Compose), schemas (SQL, OpenAPI, AsyncAPI, Protobuf, GraphQL), and live infrastructure (Docker, Terraform state). The project is packaged as an AI agent skill compatible with Claude Code, Cursor, Copilot, and other Agent Skills hosts, and ships with GitHub Actions for CI integration. While primarily an application, it also bundles curated icon indices and style presets that could be considered data assets.
This repository is a bilingual curated awesome-list for Agent Skills focused on "persona distillation" — distilling expressive style, decision frameworks, and interaction patterns from people, relationships, conversations, works, or digital traces. The primary content is two static README files (Chinese and English) listing ~70 projects across five categories, sorted by repository name for maintainability. The codebase itself is not an end-user application; it is the curation infrastructure behind the list: a set of Bun/Node.js scripts, GitHub Actions workflows, and tests that automate the submission, validation, and merging of new entries.
OPC Skills is a curated marketplace and toolchain of AI agent skills designed for solopreneurs, indie hackers, and one-person companies. The repository contains 9 skills (reddit, twitter, producthunt, domain-hunter, logo-creator, banner-creator, nanobanana, seo-geo, requesthunt, archive) that each provide structured prompts and Python scripts to automate tasks like market research, SEO/GEO optimization, domain hunting, logo/banner creation, and social media analysis. Skills are distributed via the Agent Skills standard (`npx skills add`) and also available as a Claude Code plugin. The project includes a full website at opc.dev powered by a Cloudflare Worker (website/worker.js) with per-skill pages, a blog, SEO/GEO optimization, and install statistics tracking. CI/CD pipelines deploy the website, test installs across platforms, and fetch install stats daily. The codebase follows a consistent architecture: each skill has a SKILL.md with YAML frontmatter, optional Python scripts following a credential → API wrapper → per-endpoint script pattern with TOON (Token-Oriented Object Notation) output, and dependencies declared between skills. While primarily an application, it has data-research characteristics due to its heavy use of external API scraping for market signals (Reddit, Twitter, ProductHunt) and SEO analytics. The repository is actively maintained with frequent releases, a changelog, and an agent-assisted development workflow (Ralph). Notable strengths include the reusable skill template pattern, cross-session memory via the archive skill, and the standalone SEO audit script. Key risks include reliance on multiple third-party API keys, tight coupling between some skills, and fragility in the install stats scraper.
AgentSkillsHub is a production-grade web application that indexes, grades, and surfaces open-source AI agent skills, MCP servers, and Claude/Codex skills. It operates as a full-stack directory with a trust-layer differentiator: each skill receives a deterministic security grade (SAFE/CAUTION/UNSAFE/REJECT) from a rule-based scanner (35 patterns across 11 categories) and a composite quality score (10 signals). The system is architected as a FastAPI monolith (backend) with a React SPA frontend pre-rendered for SEO via 13+ build-time generators, backed by Supabase (PostgreSQL) and triggered by GitHub Actions every 8 hours. It ingests data from the GitHUB Search API through a 6-phase pipeline (search → metadata → README fetch → scoring → classification → composability), then serves the catalog via static HTML pages, REST API endpoints, an MCP server, and a CLI tool. Monetization includes a Pro tier with paid deep search, a $49 deep-audit per skill, and enterprise subscriptions. The codebase also produces original research: a published dataset of 130k+ graded skills, an arXiv paper on security distributions, a 12-chapter Blue Book, and extensive SEO/GEO strategy documents. Despite its hybrid nature (both a software application and a data research project), the dominant character is application because the running web service is primary; the research outputs are byproducts of the operational pipeline.
Google AI Edge Gallery is an Android application that serves as a showcase and playground for on-device AI models, primarily Gemma 4 and other LiteRT-compatible LLMs. It provides a rich set of interactive tasks including AI Chat, Prompt Lab, Ask Image, Audio Scribe, Tiny Garden (a mini-game powered by a 270M model), Mobile Actions (device control via function calling), and an Agent Skills system with MCP (Model Context Protocol) integration. The app manages the full lifecycle of on-device models: discovery (via HuggingFace), download, initialization, inference, and benchmarking. It features a plugin architecture via the CustomTask interface, allowing new tasks to be registered through Hilt dependency injection. Skills are defined as markdown instruction files paired with JavaScript functions executed in a WebView, enabling extensible tool use. The codebase is well-structured with Jetpack Compose UI, Proto DataStore persistence, Firebase Analytics, and a clean separation of concerns. It is a professional-grade demo application that demonstrates advanced on-device AI capabilities, though some areas (e.g., skill duplication, large ViewModels) show signs of rapid development.
This monorepo (Nx) implements a complete ecosystem for managing and distributing 'skills'—curated, structured instructions for AI coding agents. The codebase reveals a production CLI (`agent-skills`) built with Ink/React for interactive terminal UI, an MCP server (`agent-skills-mcp`) for agent-in-context skill lookup via FastMCP, a Next.js marketplace website for browsing, and a skills catalog with over 150 skill definitions across architecture, cloud, development, quality, security, and other domains. The core library (`@tech-leads-club/core`) uses a clean hexagonal architecture with port/adapter separation for file system, HTTP, environment, logging, and shell operations, enabling testability and future portability. The CLI supports interactive and non-interactive install/remove/update workflows with atomic lockfile writes, append-only audit logging, and content-hash integrity verification. The MCP server implements a progressive disclosure pattern (search → read → fetch/prepare) to minimize token usage, with registry caching and ETag revalidation. The marketplace is highly SEO-optimized with JSON-LD structured data, breadcrumbs, and static generation. Property-based tests (fast-check) for UI components and cache boundaries demonstrate strong engineering discipline. The skills catalog itself is the core product—each skill is a markdown file with YAML frontmatter, optional scripts/references, and trigger phrases, all validated by a custom validation tool and security-scanned in CI. While the architecture is solid and the codebase is actively maintained with frequent releases, some areas show drift risk: duplicate validation scripts across skills, hardcoded benchmark data in the marketplace, and tight coupling to external CDN availability for registry downloads. The cloud-deploy skill references an enormous set of Cloudflare product docs that will inevitably become outdated. Overall, this is a well-crafted, modern TypeScript monorepo that effectively solves the problem of giving AI agents reusable, safe, and discoverable instructions.
This is a knowledge/content repository, not a running software system: a curated collection of 11 'Agent Skills' packages compliant with the Agent Skills specification (agentskills.io), designed to be loaded on-demand by AI coding agents (Claude Code, Codex, Cursor, etc.) and other LLM runtimes. Each package is a self-contained directory with a SKILL.md entry point (YAML frontmatter with name/description plus routing instructions), plus references/, assets/, scripts/, and optional agents/ metadata. The skills cover research-analysis (deep-architecture-research with a confirmation-gate and evidence-ledger protocol; neural-mechanism-research; review-ai-conversations with reverse-engineered adapters for Claude Code, Codex, opencode, Grok Build, and Cursor conversation stores; understanding-first-report), software engineering (vibe-coding with scenario/domain/phases sub-references), team collaboration (meeting-coach-leader/worker), agent development (agent-builder with actual Python starter code; skill-judge with a 120-point rubric), and content publishing (media-writer for 7 platforms). There is no application entry point, server, or pipeline; the 'product' is the instructional content and routing logic itself. Although classified as application due to its standalone Python tools and operational guidance (rather than data pipeline), the repo is fundamentally a hybrid: most value comes from the rigor of its written protocols and evaluation rubrics, not executable code. The only real code lives in agent-builder (~4 self-contained Python files: minimal-agent.py, subagent-pattern.py, tool-templates.py, init_agent.py) which implement a clean, security-conscious agent loop. The most impressive craft is the data-engineering-style documentation in review-ai-conversations, which precisely specifies the storage schemas (SQLite tables, JSONL shapes, lineage/parent-child rules) of five proprietary agent tools, each fact tagged with provenance evidence ([CODE]/[DOC]/[ISSUE]) and version-pinned research dates. The skill-judge rubric and deep-architecture evidence protocol likewise demonstrate non-trivial expertise: hard gates, severity levels, evidence-vs-inference discipline, and explicit anti-patterns. The repo is actively maintained (last commit 2026-09-16, in-repo evidence research dated 2026-08-23, plus a documented skill-rename migration path in the READMEs, which exist in English, Chinese, and Japanese). Technical drift is low: the pinned model (claude-sonnet-4-20250514), SDK usage, and cited external tools (Codex 0.148.0, Cursor 2026.08) are current. No test suite exists, but that is the wrong bar for a documentation-oriented collection; the applicable standards are structural validity, evidence quality, and progressive-disclosure design, which are handled well. Weaknesses: media-writer's platform guides are somewhat generic social-media advice, some philosophical prose is repetitive, and the Python examples lack a requirements.txt/pinned dependency file.
Mimeo is a Python CLI application that transforms a named expert's public body of work (essays, talks, interviews, podcasts, papers, etc.) into a structured, source-verified Agent Skill file (SKILL.md) and/or AGENTS.md, designed for AI coding agents to adopt the expert's reasoning style. The pipeline orchestrates identity resolution, source discovery via the Parallel API, content fetching (web, YouTube transcripts, optional audio transcription), LLM-based distillation and clustering (via OpenRouter), quote verification against source text, structured skill authoring, critique/refinement loops, and optional avatar generation. The output is a curated set of markdown files (principles, frameworks, mental models, anti-patterns, heuristics, quotes) organized per expert in the `output/` directory. The codebase is well-architected with async stages, a fingerprint-based caching layer, SSRF-safe HTTP helpers, prompt injection mitigations, and extensive offline tests using fake LLM/Parallel clients. While the primary purpose is the application tool, the generated output forms a reusable knowledge base of expert reasoning patterns, giving the repo a hybrid character.
Cognee is an open-source AI memory platform that enables agents and applications to build, store, and query persistent knowledge graphs from documents, code, and conversations. The system provides a Python SDK, a FastAPI REST API, a CLI, a Next.js frontend, and an MCP server for agent integration. Core operations include ingesting data (remember), extracting entities and relationships via LLMs or GLiNER (cognify), retrieving context (recall), and self-improvement loops (improve). The architecture is modular with adapter/registry patterns for graph databases (Ladybug, Neo4j, Turso), vector stores (LanceDB, PGVector), LLM providers (LiteLLM, OpenAI, Anthropic, Ollama), and integrations (Slack, GitHub, Google Drive). The frontend provides a dashboard for dataset management, knowledge graph visualization, and business analytics. The project also includes an evaluation framework for benchmarking retrieval strategies against standard datasets like HotpotQA and BEAM. While production-grade in many areas, some components are marked as demo-quality or have cloud-only stubs.
Crawlkit is a shared Go library and CLI tool (crawlctl) for building local-first crawler archives. It provides provider-neutral building blocks including SQLite stores with FTS5, snapshot/export to gzipped JSONL shards, Git-based mirroring with immutable tags, encrypted backup with age/gzip and SHA-256 deduplication, sync state management with legacy adapters, vector search (exact cosine similarity and optional turbovec Python bridge), embedding providers (OpenAI, Ollama, llama.cpp), a terminal UI (Bubble Tea) for browsing archive rows, and a remote archive client for Cloudflare Workers. The CLI discovers installed crawl apps (e.g., gitcrawl, discrawl) and runs configured refresh jobs under a single-process lock. The architecture is modular and composable, with clear ownership boundaries documented in docs/boundary.md. The repository also includes agent skills (autoreview, crabbox) for automated code review and remote validation, reflecting heavy agent-driven development. It is not a generic web crawler but a mechanics layer that makes each crawl app smaller and more uniform.
chubbyskills is a personal knowledge management CLI toolkit that ingests content from over a dozen platforms (YouTube, Bilibili, X, Xiaohongshu, WeChat, Douyin, Podcasts, etc.), transcribes audio/video locally or via cloud providers, and outputs structured Markdown notes with YAML frontmatter (schema v1). The system is architected as a collection of modular "skills" (one per platform) orchestrated by a unified CLI (`tools/chubby.py`), with shared utilities in `chubby_common/`. It includes an incremental knowledge base indexer using SQLite FTS5 and optional semantic embeddings, an MCP server exposing six tools for AI agent integration, and a deterministic evidence brief generator with integrity validation. Operation is local-first: transcription uses SenseVoice and faster-whisper, video downloading uses yt-dlp, and all processing is designed to work offline. Cloud transcription (Atlas/MuAPI) and LLM enrichment (DeepSeek) are optional extensions. The repository also provides a skill installer, platform smoke testing, output validation, and retry mechanisms with credential redaction. Despite the breadth, the codebase maintains clean separation of concerns, with the shared library standing out as a reusable zero-dependency core.
This is a VS Code extension that provides a unified interface for discovering, installing, and managing MCP (Model Context Protocol) servers and AI agent skills. It integrates with multiple sources: the Official MCP Registry, skills.sh, GitHub repositories, and CloudMCP (a hosted alternative). The extension offers a chat participant (`@mcp`) for natural-language search and install, and a sidebar webview with search and management tabs. It supports 30+ AI coding agents including GitHub Copilot, Claude Code, and Codex CLI. The architecture consists of a TypeScript extension backend (using esbuild for bundling) and a React 19 + Vite + Tailwind CSS + shadcn/ui frontend, communicating via typed RPC messages. Telemetry is collected anonymously with standardized error classification. The codebase is well-structured with clear separation of concerns, CI/CD pipelines, and unit tests.
This repository is a hybrid: it is primarily a curated awesome list for Claude Code resources, but it is backed by a real automation layer that treats the README as a generated artifact. The single source of truth is a CSV resource table plus a config.yaml that defines category ordering; a Python script (generate_readme.py) renders the README, ticker SVGs, and recently-added carousels. The repo also includes GitHub Actions workflows that validate new resource submissions via issue forms, handle maintainer approval/rejection commands, and automatically open PRs to add approved resources. This makes it less of a static list and more of a self-maintaining content pipeline.
FigMirror is a reference-conditioned scientific figure style transfer system that iteratively generates matplotlib scripts matching the visual style of a reference figure. It operates as a multi-agent loop (Drawer/Reviewer) orchestrated by a runner backend (Codex, Claude, or Mock), with a local web UI for upload, iteration browsing, and refinement. The system is packaged as skills for both Claude Code and Codex, plus a standalone web server. While primarily an application, it has a strong research component: the prompts, aesthetic library, and evaluation benchmarks (PlotTwin-Bench) are the result of extensive empirical iteration. The codebase demonstrates high craftsmanship in its runner architecture, atomic file operations, SSE streaming, and deterministic review gates. However, it suffers from dual skill bundles (Claude/Codex) that must stay synchronized, retired artifacts, and some incomplete features (ClaudeRunner, SSE integration).
This repository is the official community library for GitHub Copilot customizations, including agents, skills, instructions, plugins, canvas extensions, git hooks, and a cookbook of SDK recipes in multiple languages. It also hosts a production-quality React website (Astro + Primer Brand) that catalogs all resources with search, filters, and detail pages. The codebase is primarily a collection of markdown files, JavaScript/TypeScript modules, and Python scripts, organized into well-defined directories with validation tooling in `eng/`. While the website and some extensions (draw, pr-artifact-explorer, arcade games) demonstrate solid front-end architecture, the majority of content is declarative configuration and documentation. The repository is actively maintained with frequent commits and CI workflows, though the sheer volume of community contributions introduces inconsistency risks in skill structure and dependency pinning.
oh-my-antigravity (OmA) is an extension for Gemini CLI that adds a structured, role-driven multi-agent workflow layer on top of the base CLI. It transforms a single-session AI assistant into an orchestrated engineering pipeline with roles such as architect, planner, executor, reviewer, and verifier. The extension provides over 40 slash commands, 11 retained deep-work skills, 13 sub-agent definitions, and two shipped hooks (silent BeforeModel model router and AfterAgent learn-signal filter). The architecture is entirely extension-native, relying on Gemini CLI's extension manifest (`gemini-extension.json`), command definitions in TOML files, agent prompts in Markdown, and hook scripts in JavaScript. The primary data flow is user input → `/oma:*` command → staged pipeline (intent → workspace → team-assemble → team-plan → team-prd → team-exec → team-verify → team-fix → loop) with persistent state in `.omg/state/`. The codebase demonstrates strong engineering discipline with version consistency checks, skill metadata validation, atomic file writes, environment-variable-driven runtime controls, and thorough documentation. It is not a data research project; it is a workflow automation and context-engineering pack for an AI terminal agent.
This repository is a curated directory/registry of 5,300+ community-built skills for OpenClaw, an AI agent platform. It is not a software application — it contains no runtime code, no API, and no executable logic. Instead, it is a structured catalog of markdown files organized into 30+ categories (DevOps, Search & Research, Coding Agents, etc.), where each entry links to a skill hosted on ClawHub (OpenClaw's public skills registry). The repo functions as a discovery and navigation layer: users browse categories to find skills, and contributors submit new skills via pull requests validated by a CI workflow. The repository also documents filtering criteria (excluding spam, duplicates, low-quality, crypto, and malicious entries), security considerations (VirusTotal scanning partnership), and contribution guidelines. While it shares some characteristics with a data_research repo (structured metadata, no application code), it is best classified as a curated content registry — the 'application' label applies only in the sense that it is not a data pipeline or research project. Key patterns include a consistent category taxonomy, a PR validation workflow, and documented quality gates. The main risks are link rot (5,300+ external links with no automated checking), quality variance across entries, and the manual effort required to maintain a list at this scale.
This repository is a curated collection of 177+ domain-specific scientific 'skills' for AI agents, following the Agent Skills standard. Each skill is a self-contained module providing a CLI tool, documentation, and tests for a specific scientific or technical task—ranging from single-cell RNA-seq analysis (scanpy) and molecular docking (diffdock) to clinical report validation and ISO standards readiness. The architecture is a monorepo of independent skills, each with its own scripts/, references/, assets/, and tests/. Skills are designed to be safe, bounded, and reproducible: they validate inputs before execution, enforce resource limits, avoid network access unless explicitly required, and produce structured JSON reports. The repository also includes a shared test infrastructure (skill_contract) and a meta-skill (autoskill) that can automatically propose new skills from screen activity. While primarily an application library for AI agents, it has strong data/research characteristics due to its heavy use of scientific data formats and validation of research artifacts.