Agentic Awesome Skills is a curated marketplace infrastructure for AI coding agent skills—instructional playbooks (SKILL.md files) with accompanying scripts and assets. The repository provides a multi-platform distribution system supporting Claude Code, Cursor, Gemini CLI, Codex CLI, Kiro, and others. It includes a React+Vite web application for browsing, searching, and installing skills; a CLI and MCP server for local agent integration; and a comprehensive validation, security scanning, and release pipeline. The codebase implements a transaction engine with deterministic content addressing (canonical JSON + SHA-256), durable state management, and schema-validated skill installation, forming a robust foundation for agent-owned tool selection and workflow planning. While the core infrastructure (AAS v1 library, MCP server, catalog search) demonstrates high craftsmanship and reusability, the repository is hampered by massive file duplication: identical skill scripts and governance modules appear under `skills/`, `plugins/agentic-awesome-skills/`, and `plugins/agentic-awesome-skills-claude/`, creating synchronization risk. Some skills contain hardcoded paths or incomplete boilerplate. The repository is actively maintained with CI/CD, automated audits, and security scrutiny, though the sheer volume of 2,474+ skills imposes ongoing maintenance burden. Overall, it is a well-engineered, production-quality skill distribution platform with notable reusable design patterns.
Roo Code is an AI coding assistant extension for Visual Studio Code that provides AI-powered code generation, explanation, refactoring, and debugging capabilities. It integrates with multiple LLM providers (OpenAI, Anthropic, Google Gemini, etc.) through a well-designed abstraction layer. The application features different modes (Code, Architect, Ask, Debug, Custom) for various tasks, file operations through AI, terminal integration, MCP (Model Context Protocol) support for extensible tooling, task persistence, and a chat interface for interacting with AI models. Built as a monorepo with pnpm workspaces, it consists of a core extension, webview-based UI, CLI application, and documentation site. While the original team has moved on to another project (Roomote), the README indicates a community team has stepped up to maintain and improve Roo Code.
Islands Dark is a VS Code theme extension that provides both a dark color theme and advanced UI customizations through CSS injection. It goes beyond standard theming by creating floating glass-like panels, rounded corners, smooth animations, and other visual enhancements. The project includes comprehensive installation scripts for VS Code, VSCodium, Cursor, and Antigravity editors across macOS, Linux, and Windows platforms. While the installation logic is somewhat boilerplate, the animations.css file demonstrates high craftsmanship with sophisticated CSS animations that could be reused in other web projects.
This is a Claude Code plugin and resource library, not a deployable application or data pipeline: 27 slash commands, 9+ autonomous skills, 3 auditor subagents, and extensive prompt-engineering documentation that extend the Claude Code CLI. In production, the system functions as configuration-as-code content consumed by the Claude Code runtime — teaching the assistant how to create executable plans (PLAN.md is the prompt itself), chain meta-prompts, build MCP servers, manage subagent orchestration, run autonomous coding loops (the 'Ralph' technique), and apply iOS/macOS development expertise. The only real executable code is a handful of self-contained scripts: a TypeScript CLI for The Pirate Bay API, Python/TypeScript MCP server templates, project scaffolding shell scripts, and autonomous loop iteration scripts. The dominant architectural pattern is the 'router skill': a SKILL.md entry point with essential principles, an intake gate, a routing table, and progressive disclosure into workflows, references, templates, and scripts — implemented consistently across all skills with pure XML prompt structure and checkpoint-based plan execution. Despite being classified as an application (there is no data-research character — no notebooks, datasets, or pipelines), its substance is largely authored content rather than software. The craft is strong: consistent XML schemas across files, a genuine QA layer (skill-auditor agents), secret hygiene practices, and a well-developed checkpoint/auth-gate protocol for safe automation. However, the repo carries real drift risks: duplicated reference files (research-pitfalls.md, cli-observability.md are copied across skills), dangling references to not-yet-created files, tight coupling to Claude Code's evolving plugin API, version-specific Apple platform guidance that will age, and the included The Pirate Bay skill which depends on a fragile third-party API and presents a content-policy concern. An engineer seeking to reuse this should extract the self-contained templates and scripts (MCP server scaffolding, loop automation) and treat the reference material as opinionated prompt guidance rather than canonical documentation.
Kubewall is a production-grade, open-source Kubernetes dashboard that provides real-time multi-cluster management through a single-binary web application. It combines a Go backend (Echo framework, client-go informers) with a React/TypeScript frontend (Redux Toolkit, shadcn/ui, TanStack Router) to offer live monitoring, YAML editing, pod log streaming, port forwarding, and an AI-powered troubleshooting assistant (kwAI). The architecture relies on Server-Sent Events (SSE) to push Kubernetes resource updates to the browser, with an in-memory informer cache per cluster. The backend exposes REST endpoints for every standard Kubernetes resource type as well as Custom Resource Definitions (CRDs), while the frontend uses virtualized data tables, Radix UI primitives, and lazy-loaded Monaco editor for editing. The system supports multiple kubeconfig authentication methods and includes a Helm chart for deployment.
ghstack is a Python CLI tool that enables developers to work with stacked pull requests on GitHub. It manages a stack of diffs as separate PRs using a specific branch naming convention (gh/username/N/{base,head,orig}). The tool provides subcommands for submitting, landing, checking out, pulling, cherry-picking, logging, syncing, unlinking, and managing stacked PRs. It interacts with GitHub via both GraphQL and REST APIs asynchronously (aiohttp) and relies heavily on git operations for branch and commit management. The codebase is modular with abstract endpoint classes for testability, a fake GitHub endpoint for offline testing, and a comprehensive test suite using custom pytest collection of .py.test files. Its primary value is enabling the 'stacked diff' workflow on GitHub, which is common in large engineering organizations but poorly supported natively.
CtxPort is a browser extension and companion documentation website that lets users copy AI conversations (from ChatGPT, Claude, Gemini, DeepSeek, Grok, Doubao, GitHub) as structured Markdown Context Bundles. It solves 'context rot' by enabling portable, lossless migration of conversations between AI tools without uploading data to third parties. The architecture is a modern monorepo using pnpm workspaces and Turborepo, with separate packages for schema validation (Zod), markdown serialization, plugin-based extraction, and shared UI components. The browser extension (Manifest V3, WXT, React 19, Tailwind CSS 4) injects copy buttons and sidebar list icons into supported platforms, while the documentation website (Next.js + Nextra) provides multilingual (en/zh) user guides and feature descriptions. All processing is client-side; no data is uploaded. The codebase demonstrates strong engineering practices including a plugin system for extensibility, a strategy pattern for content flatteners, clean separation of concerns, and comprehensive CI/CD pipelines. Some fragility exists in DOM selectors and platform APIs, but the architecture is well-structured for adaptation.
Stoobly Agent is a CLI-driven HTTP proxy tool for recording, mocking, replaying, and testing API traffic. Built on mitmproxy, it intercepts HTTP/HTTPS requests and applies configurable policies across four modes: record, mock, develop, and test. The tool stores intercepted requests and responses in a local SQLite database via a custom ORM, and can also synchronize with the Stoobly cloud service for remote project management. It supports lifecycle hooks (user-defined Python callables), OpenAPI endpoint import, snapshot/rollback of request state, and a scaffold system that generates Docker Compose or local development environments for services and workflows. The architecture is modular, with clear separation between the CLI layer (Click-based), proxy interception handlers, data models and adapters (converting between mitmproxy, raw HTTP, ORM, and Stoobly API representations), and a settings system with YAML persistence and environment variable overrides. Key entry points include the main CLI group (stoobly_agent/cli.py), the proxy intercept handler (stoobly_agent/app/proxy/intercept_handler.py), and the scaffold commands (stoobly_agent/app/cli/scaffold/). External dependencies include mitmproxy for traffic interception, a custom ORM (stoobly_orator) for local storage, and the Stoobly cloud API for remote features. The codebase demonstrates strong software engineering practices with extensive use of design patterns (adapter, facade, builder, singleton, strategy) and a comprehensive test suite covering unit, integration, and end-to-end scenarios. While the scaffold system and snapshot management add complexity, the overall architecture is well-organized and the tool delivers a polished developer experience for API mocking and contract testing.
This repository is a comprehensive collection of 21 self-contained AI agent implementations, each solving specific business or technical problems using various frameworks (LangGraph, CrewAI, AutoGen, Agno, LlamaIndex). Each agent is designed to be runnable end-to-end in under 10 minutes with its own dependencies, configuration, and documentation. The repository also includes a React-based web application that serves as an atlas for browsing and learning about these agents, plus an educational course on CrewAI with MCP integration. The architecture consists of independent CLI applications (the agents) coupled with a documentation/web layer that reads agent metadata for display purposes.
This is the official curated marketplace and development toolkit for Claude Code plugins, maintained by Anthropic. It contains both first-party plugins (e.g., claude-security, code-modernization, hookify, skill-creator, security-guidance) and third-party channel integrations (Discord, iMessage, Telegram, GitHub, Linear, etc.). The repository serves dual roles: as a plugin registry with standardized packaging (SKILL.md, agent definitions, hooks, commands, MCP servers) and as a meta-development kit providing tools for authoring and validating new plugins. The codebase is predominantly instructional content for Claude Code (markdown workflows, agent system prompts, skill references) orchestrated through hooks, workflows, and commands. While many plugins contain only reference documentation and no executable code, security-critical plugins like claude-security and security-guidance include sophisticated Python/JavaScript logic for vulnerability scanning, patch generation, session state management, and git diff analysis. The CI pipeline enforces licensing (Apache 2.0), validates plugin structure, checks MCP URL liveness, and manages SHA-pinned external plugin versions. The project is actively maintained but exhibits technical drift from duplicated access-control logic across channel servers, hardcoded model references, and reliance on Claude Code CLI internals that may change between versions.
This repository is an awesome list of Visual Studio Code extensions and resources, with the README.md serving as the primary product. It does not contain a runnable application but functions as a curated reference guide for developers seeking VS Code extensions. The repository includes a GitHub Actions workflow (links.yml) that automatically validates all links in the README using the awesome_bot tool to prevent link rot. Contributions are governed by strict guidelines ensuring consistent formatting, alphabetical ordering, and inclusion of screenshots/GIFs where possible. While the core content is static, the CI pipeline demonstrates a reusable pattern for documentation maintenance in open-source projects.
npkill is a TypeScript CLI/TUI application that scans filesystems to find node_modules (and other ecosystem build/dependency directories) consuming disk space, then interactively or programmatically deletes them. The core engine (Npkill class) exposes RxJS observable streams for scanning, size calculation, newest-file detection, deletion, and logging, with a worker_threads-based parallel directory traversal. The CLI layer adds a raw-mode interactive terminal UI with cursor navigation, multi-select deletion, search filtering, JSON/NDJSON output modes, --dry-run, .npkillrc config file support, and user-defined profiles. It ships both as a bin executable and as a programmatic Node library per API.md.
MooTool is a cross-platform developer toolbox with over 30 utilities including JSON formatting, HTTP client, regex testing, encryption/decryption, color picker, diff viewer, QR code, cron expressions, translation, image processing, PDF manipulation, code runtime, and more. The repository contains three concurrent implementations: a legacy Java Swing desktop application (with FlatLaf theming and MyBatis/SQLite persistence), an Electron+React+TypeScript rewrite (using CodeMirror, pdf-lib, and native IPC bridges), and a Tauri 2 (Rust+React) version with additional native features like screen capture, system tray, and updater integration. A macOS native SwiftUI app is also provided as a preview. The architecture is modular per tool, with shared contracts across platforms, session tracking, operation history, and vault-based note storage with Git versioning. Key entry points include the Java MainFrame, the Electron main process (electron/main/index.ts), and the Tauri Rust backend commands. Data flows are entirely local (SQLite, file vault, settings JSON) with no cloud dependency except automated translation APIs and optional update checks. External dependencies include Java runtime, Git, protoc, Tesseract OCR, system keyring, and translation web services (Google, Bing).
Dingo is a source-to-source transpiler for a custom language that extends Go with Rust-inspired features like sum types (enums), pattern matching, error propagation (`?`), safe navigation (`?.`), null coalescing (`??`), lambdas, tuples, and functional utilities (Option/Result). The transpiled output is clean, idiomatic Go with zero runtime overhead. The repository includes a full CLI tool (`dingo`) with build, run, fmt, lint, and update commands, as well as a language server (`dingo-lsp`) that wraps gopls as a proxy and uses source maps (`.dmap` binary format) for position translation. Editor integrations cover VS Code, Neovim, and JetBrains. The codebase is organized as a monolith with a modular plugin architecture for AST transformations. While actively developed and containing several well-crafted reusable components (source map binary format, error formatting with carets and suggestions, concurrent type cache, animated terminal mascot), the project shows signs of architectural fragmentation: duplicate parser implementations, a legacy preprocessor coexisting with a newer AST pipeline, multiple skipped tests, and known incomplete features tracked in TODOs. The scope is ambitious — many language features are implemented but the overall coherence suffers from incremental AI-assisted development patterns visible in the extensive ai-docs archive.
This repository is an 'awesome list' — a static Markdown index of externally hosted Claude Code skills, organized into 14 categories (documents, development, data, science, writing, learning, media, health, collaboration, security, utility, articles, and collections). It contains no source code, no executable skills, no CI/CD, and no tests. The production function is discovery: a human or AI agent reads the README to find third-party skill repositories, then clones or installs those skills separately. Architecture is a single README with external links plus a few embedded sponsor images. There are no data flows or APIs. The list is actively maintained with a recent commit and a large volume of open issues, indicating ongoing community input. The core value is the curation and categorization of 150+ external skills, not software engineering craftsmanship. Sponsored placements appear at the top, so it is not purely community-driven. Overall, a useful and well-organized directory, but with zero in-repo technical content.
This repository is a curated collection of Claude skills—markdown instructions and supporting scripts that enable Claude (or any MCP-compatible agent) to perform a wide range of tasks, from document manipulation (DOCX, PPTX, PDF, XLSX) and GIF animation to web testing, MCP server building, and automation of hundreds of third-party SaaS services via Composio's Rube MCP. The repo is primarily a skill library with a standardized template for each skill, but it also contains several well-crafted Python libraries (e.g., easing functions, particle systems, OOXML validation frameworks) that are genuinely reusable. The architecture is modular: each skill lives in its own directory with a SKILL.md and optional scripts. The heavy reliance on external services (Composio, Rube MCP) and the massive duplication of templated skill documentation introduce maintenance risks, but the core utility scripts demonstrate solid engineering craftsmanship.
tsumiki is a Claude Code plugin and skill library that operationalizes AI Test-Driven Development (AITDD). It exposes slash commands (`/dev-impl`, `/dev-debug`, `/ipa-security-check`, `/orchestrate`) and Markdown-based skills that guide an AI coding agent through a Red-Green-Refactor-Validation cycle. The repository is not a standalone runtime; it is a development methodology toolkit whose primary artifacts are command definitions, skill instructions, and workflow orchestration logic consumed by Claude Code.
This is a curated collection repository of Cursor AI editor rules (.mdc files), not a traditional software application. It functions as an awesome-list style repository that aggregates project-specific configuration files for the Cursor AI code editor. The repository contains over 200 rule files covering various programming languages, frameworks, testing methodologies, and development workflows. The architecture is straightforward: a flat collection of .mdc files in the rules/ directory, with a README.md serving as the index and discovery mechanism. The repository includes Node tooling for maintaining quality and consistency: scripts for checking repository hygiene, validating awesome-list format, converting README links between relative and absolute forms, checking PR author age policies, and cleaning up legacy artifacts. The CI/CD pipeline uses GitHub Actions with a main workflow file. The key value proposition is providing reusable Cursor AI configuration files that developers can drop into their .cursor/rules/ directories. Each rule file contains frontmatter metadata (description, globs pattern, alwaysApply flag) followed by instructions that guide Cursor AI's behavior for specific technology stacks or development patterns. The rules range from framework-specific guidance (React, Vue, Next.js, Svelte) to language best practices (TypeScript, Python, Go, Rust) to specialized domains (embedded systems, blockchain, machine learning workflows). The repository demonstrates moderate engineering quality in its maintenance tooling, with centralized configuration, test coverage for scripts, and automated quality checks. However, the rule files themselves vary significantly in quality and depth - some are comprehensive and well-structured while others are minimal or boilerplate.
Knife4j is an enhanced Swagger/OpenAPI user interface and aggregation toolkit for the Java Spring ecosystem. In production it deploys as a set of Spring Boot auto-configuration starters: openapi2 (springfox), openapi3 (springdoc), aggregation from disk/cloud/Nacos/Eureka/Polaris sources, and Spring Cloud Gateway discovery, plus an optional standalone `knife4j-insight` server and multiple frontend UIs (Vue 2, Vue 3, React/Ant Design Pro). The core data flow is: a Spring Boot service exposes OpenAPI JSON via springdoc/springfox; Knife4j customizers and plugins enrich that JSON with API ordering, markdown docs, global parameters, and enhanced metadata; the frontend consumes the OpenAPI document and renders API lists, debug consoles, OAuth2 flows, and offline export pages. Aggregation starters fetch and merge specs from remote registries or local files, cache them in memory, and proxy or route requests to upstream services.
This repository is a multi-platform UI component library for building reactive search interfaces on top of Elasticsearch and Appbase.io. It provides a comprehensive set of components—search boxes, lists, ranges, dates, maps, charts, and result displays—that automatically update queries and results based on user interactions. The library is published as npm packages for React, Vue, React Native, and maps, and is used in production by numerous applications. Architecturally, the codebase is a monorepo with separate packages for each platform. Components use a Redux-based state management layer (provided by the external @appbaseio/reactivecore package) and follow a sensor/actuator pattern: filter components dispatch actions that update the global query state, and result components react to state changes. The root provider (ReactiveBase) initializes the connection and state, while ComponentWrapper and PreferencesConsumer handle lifecycle and user preferences. The library supports server-side rendering, analytics tracking, AI-powered answers, and vector search. Key entry points are the package index files (e.g., packages/web/src/index.js) that export all components. External dependencies include @appbaseio/reactivecore for state management, appbase-js for backend communication, emotion for CSS-in-JS, and Downshift for autocomplete. While the library is functional and widely adopted, the codebase exhibits significant duplication across platform packages, large monolithic component files (e.g., SearchBox.js ~2000 lines), snapshot-only tests, and some deprecated patterns (eval in chart rendering, hoistNonReactStatics). These factors contribute to a moderate quality score.