This repository is a meticulously crafted template for using AI coding agents to reverse-engineer live websites into clean, modern Next.js codebases. It provides a pre-configured Next.js 16 scaffold (with shadcn/ui, Tailwind v4, and TypeScript strict) alongside a sophisticated set of agent instructions that guide the AI through the entire cloning process: mapping URLs, observing the target, building components, and comparing results. The project is not just a code scaffold; it is a complete workflow definition designed for Claude Code, Codex, Cursor, and OpenCode. The architecture is elegantly split between the application scaffold (src/, public/) and the agent skill definitions (.agents/skills/clone-website/). The canonical skill (SKILL.md) and its references (inspection-guide.md, framer-and-motion.md) represent a masterclass in prompt engineering, providing concrete, actionable guidance for handling complex scenarios like Framer-generated pages, scroll-driven animations, and responsive asset extraction. The project structure enforces clean separation of concerns for multiple cloned sites. The codebase demonstrates exceptional craftsmanship and a deep understanding of both software engineering and AI agent capabilities. The highlighted components—the agent skills, the token-counting CI workflow, and the cross-platform agent configuration—are genuinely reusable patterns that solve non-obvious problems. This is a rare example of a template that is more valuable for its workflow and documentation than its application code, setting a high standard for AI-assisted development projects. Maintenance is active, technical drift is low, and the project is a strong 9.0 on the quality scale.
Dify is an open-source LLM application development platform that serves as a visual workflow builder, agent orchestration engine, RAG pipeline, and LLMOps backend-as-a-service. In production, it enables users to create, deploy, and monitor AI-powered applications including chatbots, text generation, autonomous agents, and complex multi-step workflows. The architecture is a monorepo consisting of a Python/Flask API backend with SQLAlchemy and Alembic migrations, a Next.js web console, a TypeScript CLI (difyctl), a Go-based agent runtime sandbox, and shared packages for contracts and UI components. Key entry points include the console web app for building and managing apps, the service API for integrating external systems, and the OpenAPI surface for third-party clients. Primary data flows involve user authentication, workflow execution (triggered by APIs, schedules, or webhooks), knowledge ingestion and retrieval (document extraction, chunking, embedding, vector search), and agent invocation (tool calls, LLM interactions). External dependencies include multiple vector databases (pgvector, Qdrant, Weaviate, etc.), LLM providers (OpenAI, Anthropic, etc.), object storage (S3, Azure Blob, etc.), Redis, Celery, and various observability backends (OpenTelemetry, Langfuse, etc.). The platform supports multi-tenancy, RBAC, billing, and enterprise features, and is deployed via Docker Compose, Kubernetes, or cloud-specific distributions.
LobeHub/LobeChat is an open-source AI agent orchestration platform delivered as a full-stack monorepo. It provides a web SPA (Next.js), an Electron desktop application, a CLI tool, and a server backend. The system enables multi-model AI chat, agent definitions with built-in and MCP tool integration, user memory and knowledge bases, evaluation workflows, and acceptance testing. The architecture is modular with packages for model runtime, built-in tools, database (Drizzle ORM + PostgreSQL), prompts, and state management (Zustand). Key entry points include the Next.js app routes, tRPC routers for server-side logic, Hono API for agent execution and workflows, and the Electron main process for desktop features. Data flows involve user messages routed through an agent runtime that coordinates LLM providers, tool execution, and response streaming. External dependencies include PostgreSQL, Redis, S3-compatible storage, various LLM APIs, Upstash QStash for background workflows, and optional Elasticsearch for full-text search.
This is a monorepo for managing a curated catalog of 'skills'—packaged markdown instructions that extend AI coding agents (Cursor, Claude Code, Copilot). It provides three main surfaces: a CLI (Ink/React TUI) for installing/updating/removing skills, an MCP server (Model Context Protocol) for agent-native access, and a Next.js marketplace for browsing. The core library implements a clean port/adapter pattern for filesystem, HTTP, shell, and environment operations, with a robust lockfile system, content-hash verification, and CDN-based registry distribution. The codebase is well-structured, well-tested, and actively maintained, demonstrating high craftsmanship in dependency injection, state management, and progressive disclosure patterns.
Skybridge is a production-grade, full-stack TypeScript framework for building interactive MCP (Model Context Protocol) Apps and ChatGPT Apps. It provides a unified runtime to develop server-side tools with rich React-based UI views that render inside AI chat hosts like ChatGPT, Claude, Cursor, and VSCode. The framework is structured as a monorepo with packages for the core server/client library (`skybridge`), a Vite plugin for build orchestration, a developer tools SPA for local debugging, a project scaffolding CLI (`create-skybridge`), and an eval/test harness. The architecture centers on a typed MCP server implementation that handles tool registration, per-tool OAuth 2.1 authentication, an onion-model middleware system, and view resource serving. On the client side, a bridge abstraction (HostAdaptor) normalizes communication across different host protocols (OpenAI Apps SDK vs. MCP App JSON-RPC), while React hooks provide type-safe access to tool calls, view state, user context, and display modes. The framework emphasizes a 'reason, then render' two-phase pattern: a tool call computes data, then a view displays it interactively. Extensive examples cover e-commerce, games, authentication, productivity dashboards, and generative UI, demonstrating the framework's flexibility. Skybridge is not a data research project; it is a developer toolchain for building agent-native applications.
Graphify is a CLI tool and library that extracts structural and semantic knowledge graphs from source code across 36+ programming languages. It parses files using tree-sitter grammars, builds a graph of nodes (functions, classes, modules, etc.) and edges (calls, imports, inheritance, etc.), performs community detection via Leiden/Louvain, and generates reports, wikis, and exports to formats like Obsidian, Neo4j, and FalkorDB. The system integrates with AI coding assistants through an MCP server (stdio/HTTP), skill files (SKILL.md, CLAUDE.md), and git hooks for automatic graph updates. Key entry points include `graphify extract`, `graphify query`, `graphify serve`, and `graphify install`. External dependencies include tree-sitter grammars, LLM APIs (OpenAI, Anthropic, Gemini, Ollama), and optional databases. The architecture is modular: per-language extractors in `graphify/extractors/`, graph assembly in `build.py`, clustering in `cluster.py`, and export in `export.py`. The codebase demonstrates strong engineering practices with extensive tests, atomic file writes, security validation (SSRF, path traversal), and cross-platform support.
This is a large polyglot monorepo for WiFi-based human sensing (WiFi-DensePose) that turns commodity WiFi routers into spatial intelligence systems. It captures Channel State Information (CSI) from ESP32 nodes to detect presence, estimate 17-keypoint body pose, measure breathing and heart rate, and track movement through walls without cameras or wearables. The system integrates deeply with Home Assistant via MQTT and Matter, provides a HomeKit bridge, and exposes multiple surfaces: a Rust backend workspace (v2/crates) with 50+ crates for signal processing, privacy shielding (VEIL/BFLD), pose physics, and home automation; Python bindings (PyO3) for ML training and inference; TypeScript CLI and MCP tools for AI agent integration; ESP32-C6/S3 firmware with adaptive sensing; React Native mobile app; Lit-based dashboard; and Tauri desktop app. The architecture is event-driven with a streaming engine, coherence-gated privacy layers, and deterministic verification via SHA-256 golden files. The codebase is heavily ADR-driven with extensive test coverage including cross-language parity gates. While primarily an application, it also contains substantial research code (benchmarks, physics simulations, SOTA surveys) and is best described as a research-informed production platform.
Ruflo is a large, modular AI agent orchestration platform that extends Claude Code with a plugin ecosystem, swarm coordination, memory systems, neural learning, security enforcement, and federation. The core is a CLI tool (`npx ruflo`) that provides 26+ commands and 215+ MCP tools for managing agents, memory, security, hooks, and deployments. It includes a console UI inside Claude Code, a Svelte-based chat UI (ruvocal), and a React-based goal UI. The architecture is ADR-driven with clean separation into domain, application, and infrastructure layers across 35+ plugins and 20+ core packages. The system implements advanced patterns: CQRS for memory and swarm, circuit breakers for resilience, capability envelopes for security, Ed25519 signing for release integrity, and a harness loop for automated champion selection. It supports multi-model routing, hybrid vector search (HNSW + SQLite), watermarking (WASM-based Gumbel scheme), and neural learning (PPO, DQN, Decision Transformer). Federation enables cross-installation agent collaboration with zero-trust, HMAC-signed envelopes, and PII-gated data flow. While the codebase is well-structured and actively maintained, it has some maintenance risks: duplicate helper scripts across multiple directories, hardcoded version numbers in smoke tests, experimental alpha plugins, and a large regression test suite that requires ongoing upkeep. The plugin ecosystem is extensive but some plugins may be aspirational rather than production-ready.
OfficeCLI is a cross-platform CLI application written in C#/.NET that creates, reads, and mutates OOXML Office documents (Word .docx, Excel .xlsx, PowerPoint .pptx) without requiring Microsoft Office. It is explicitly engineered as an agent-facing tool: every document element is addressable through a uniform path syntax (e.g. /slide[1]/shape[2]), all commands emit structured JSON with error codes and suggestions, and it ships AI-skill files for Claude/Copilot/Cursor/Codex, an MCP server, plus Python and Node SDKs. The core operation model is a batch command language: documents are mutated by replayable JSON items (add/set/remove/get) executed atomically through the CLI or over a named pipe to a resident process. Architecturally the repo is a single .NET binary (embedded runtime) with a CommandBuilder layer, a DocumentHandlerFactory dispatching to three large partial-class handlers (WordHandler, ExcelHandler, PowerPointHandler), and a shared Core layer containing chart-to-SVG rendering, a formula evaluator implementing 350+ Excel functions with statistical distributions, pivot table construction, Mermaid diagram parsing, OOXML theme/table-style resolution, HTML/PNG/SVG preview rendering, and a plugin protocol for foreign-format dump-readers and exporters. Security is taken seriously: SsrfGuard validates remote fetch targets, HyperlinkUriValidator allowlists URI schemes, XmlTextValidator and DocumentLimits guard against decompression bombs and DOM sprawl, and AtomicPackageWriter prevents torn file writes. Quality is strong but carries real maintenance debt. The code demonstrates deep OOXML craftsmanship - schema-order-correct XML insertion, exact EMU unit round-trips, Lanczos-based gamma functions, and curated chart-style galleries. However, handlers are split across dozens of partial-class files that evolved from former god methods, the property API is stringly-typed (props dictionaries parsed per key), examples must be maintained in parallel shell and Python twins, and the tool deliberately tolerates 'UNSUPPORTED props' warnings (exit code 2), which can mask incomplete feature coverage. The best reuse targets are the self-contained Core utilities rather than the format handlers. The project is actively maintained with multi-platform CI publishing to npm and PyPI.
This is a monorepo of six AI agent skills (SKILL.md format) for creative content generation, targeting Claude Code, Cursor, Codex CLI, and other compatible agents. Each skill is a self-contained package with agent instructions, reference libraries, scaffold scripts, and optional companion websites. The skills enable agents to: generate beautiful single-file HTML articles (beautiful-article), create and edit images via GPT-4o (gpt-image-2), retrieve knowledge from local files (kb-retriever), produce deterministic motion-graphics videos with audio (motion-showreel), design polished web pages with anti-AI-cliché rules (web-design-engineer), and build click-driven video presentations with TTS (web-video-presentation). The repository also includes release automation (zero-dependency Node scripts, GitHub Actions), a Claude Code plugin marketplace entry, and two showcase websites (Vite+React+TypeScript). While primarily an application toolkit, it contains structured prompt template libraries and design reference catalogs that resemble curated data assets. The codebase demonstrates high engineering craftsmanship with deterministic rendering pipelines, a session-based audio synthesizer, design token systems, and comprehensive test coverage for the motion-showreel pipeline.
The agent-skills repository provides a framework for enhancing AI coding agents with structured engineering workflows called 'skills'. Each skill encodes senior engineer best practices across the software development lifecycle (Define → Plan → Build → Verify → Review → Ship) through opinionated, process-driven guidelines. Skills are invoked automatically based on context or via slash commands and integrate with multiple AI agent tools (Claude Code, Gemini CLI, Antigravity, Codex, etc.) through tool-specific adapters. The system includes a meta-skill for dynamic skill routing, reusable agent personas for specialized tasks, and validation infrastructure to ensure consistency and prevent drift. It is designed to prevent agents from skipping critical steps by mandating concrete evidence (tests, build output) rather than relying on subjective assessments.
EverOS is a local-first, markdown-based memory framework for AI agents and chat applications. It ingests conversational sessions via a FastAPI REST API, extracts structured memories (episodes, atomic facts, agent cases, skills, user profiles) using LLMs, persists them as version-controllable Markdown files, and maintains derived search indexes in LanceDB (vector + BM25) and SQLite. The system provides a rich retrieval layer with keyword, vector, hybrid (RRF), and agentic (LLM-guided multi-round) search methods, plus a knowledge wiki feature. An Offline Memory Engine (OME) runs background strategies (reflection, clustering, extraction) on cron/idle/immediate triggers, and a cascade daemon watches the Markdown filesystem to reconcile indexes. The architecture is a layered monolith (entrypoints → service → memory → infrastructure) with cross-cutting components for LLM, embedding, rerank, tokenizer, and config. It ships with a CLI (Typer), a TUI demo (Textual), and extensive integration tests. While primarily an application, it includes a benchmark harness (LoCoMo, LongMemEval, EverMemBench) and evaluation fixtures, giving it a hybrid character with a strong research-oriented testing pipeline.
CC Switch is a desktop application built with Tauri (Rust backend + React/TypeScript frontend) that serves as a unified management hub for multiple AI coding assistants, including Claude Code, Claude Desktop, Codex, Gemini CLI, Grok Build, OpenCode, OpenClaw, and Hermes Agent. Its core function is provider switching: it manages configurations, API keys, OAuth tokens, and MCP servers across these tools, and provides a local HTTP proxy that routes API requests to different AI providers with failover, circuit breaking, and usage tracking. The application also includes session management, skills/prompts synchronization, cloud sync (S3/WebDAV), deep link import/export, and a usage dashboard with cost tracking. The architecture follows a command-service-DAO pattern in Rust, with a React frontend using TanStack Query for state management, react-hook-form for forms, and shadcn/ui components. The proxy subsystem is particularly sophisticated, implementing format conversion bridges between different AI API protocols (Anthropic Messages, OpenAI Chat/Responses, Gemini), streaming transforms, thinking budget optimization, cache injection, and content encoding handling with bomb protection. The frontend is organized around per-app provider forms, a universal provider panel, and settings pages for proxy, MCP, skills, and usage. Key features include: 50+ provider presets for third-party API relay services, one-click provider switching with live config backup/restore, a local proxy with auto-failover and circuit breaker, session history browsing across supported apps, skills installation from GitHub repos, prompt management with per-app sync, and usage statistics with custom pricing. The application supports i18n (English, Japanese, Chinese) and runs on Windows, macOS, and Linux.
Taste-skill is not a software application in the traditional sense; it is a portable library of AI-agent 'skills' - extremely detailed Markdown instruction files (SKILL.md) distributed via the `npx skills add` CLI (Vercel agent-skills spec) and a .claude-plugin marketplace. The repo's product is the prompt content itself: 13 frontend design-direction skills that agents like Claude Code, Codex, and ChatGPT load to avoid generic 'AI slop' output. The flagship is `taste-skill` v2 (`design-taste-frontend`), a ~5000-line instruction document that codifies anti-pattern bans (zero em-dashes, no section-number eyebrows, no three-equal-card rows), a brief-inference protocol, design-system mapping to official packages (Fluent, Carbon, Polaris, GOV.UK), canonical GSAP/scroll-reactive code skeletons, and a hard pre-flight checklist with mechanical pass/fail criteria. It is complemented by image-generation-only skills (brandkit, imagegen-frontend-web/mobile) that produce reference comps for downstream coding agents, plus variant skills (brutalist, minimalist, soft, stitch, output-enforcement). The repository also contains a `research/laziness/` folder documenting LLM output-truncation causes and remediation, and a small set of Node/Sharp image-processing scripts used to build the README assets. Those scripts contain one genuinely valuable, extractable algorithm: a flood-fill outer-background removal with auto-cropping to content bounds. The scripts are one-off (hardcoded `C:/Users/User/Downloads` source paths, tightly coupled to specific sponsor assets), so they are not drop-in reusable without adaptation, but the background-removal technique itself is portable. This is a content/instruction repository rather than a codebase; software-engineering quality bars (tests, CI) do not apply. Its craftsmanship lives in the rigor, specificity, and mechanical enforcement of the prompt files, which is exceptional for the prompt-engineering domain. The active development cadence, current dependency references (Tailwind v4, Motion/react, React Server Components), and 92k-star traction confirm it is the leading project in its niche.
CherryStudio is a cross-platform desktop AI assistant built with Electron and React. It provides a unified chat interface that supports dozens of LLM providers (OpenAI, Anthropic, Google, Groq, local models via Ollama, etc.) through a pluggable provider registry and the Vercel AI SDK. Beyond chat, it offers knowledge base management with RAG (vector indexing via sqlite-vec, chunking, embedding), file processing (OCR with Tesseract/PaddleOCR, document parsing), web search, image generation, MCP (Model Context Protocol) tool integration, and code CLI management (Claude Code, OpenAI Codex). The application is organized as a pnpm monorepo with separate packages for the UI component library, AI core runtime, provider registry, and tracing infrastructure. Architecturally, the app follows an Electron main/renderer process split with typed IPC communication using Zod schemas. The main process handles AI inference, database operations (SQLite via Drizzle ORM), file management, and native integrations. The renderer is a React SPA using TanStack Router, SWR for data fetching, and a custom UI component library with extensive icon sets for providers and models. The AI runtime layer abstracts provider-specific details through adapters and supports streaming, tool calls, agent sessions, and context compaction. Key data flows include: user input → composer → IPC → AI runtime → provider API → streaming response → renderer. Knowledge base ingestion follows: file upload → OCR/parsing → chunking → embedding → vector store. The application also supports offline usage with local embedding models and ONNX runtime. External dependencies include native binaries for OCR and vector search, and the AI SDK ecosystem.
This repository is not a traditional application but a distribution and runtime for 'Superpowers' – a collection of structured skill definitions (markdown files with YAML frontmatter) that shape the behavior of AI coding agents (Claude Code, Codex, Gemini CLI, etc.). The core product is a set of carefully crafted instructions (e.g., subagent-driven development, brainstorming, systematic debugging, test-driven development) plus per-harness bootstrap injection scripts, plugin manifests, and a small zero-dependency visual companion server. The project's architecture is a multi-harness plugin system: each agent platform gets a plugin manifest and a session-start hook that injects the bootstrap skill, enabling the agent to invoke Superpowers skills via a 'Skill' tool or native equivalents. The repository demonstrates high engineering craftsmanship in its skill design (rationalization tables, Red Flags, evidence-driven iteration) and in the accompanying scripts (polyglot hook runner, secure WebSocket server, worktree isolation). It is actively maintained with frequent releases and a formal design/plan/specification process. However, the primary value is in the skill content rather than reusable software components; reuse outside the Superpowers ecosystem requires adapting the bootstrap injection and tool mappings for a new harness.
JeecgBoot is an enterprise-grade low-code development platform that accelerates application delivery through AI-powered code generation, online form/report builders, and workflow integration. The backend is built on Spring Boot 3 with MyBatis-Plus, Shiro, and JWT, supporting both monolithic and microservice architectures (Spring Cloud, Nacos, Sentinel, XXL-Job). The frontend uses Vue 3 + TypeScript + Ant Design Vue with a rich component library including JVxeTable for editable grids and schema-driven forms. The platform provides comprehensive RBAC, multi-tenancy, dynamic data sources, data dictionaries, and third-party integrations (DingTalk, WeChat, Feishu). A dedicated AI module (airag) offers RAG knowledge bases, LLM chat, voice/image generation, and MCP plugin support. The codebase is actively maintained with frequent commits and a large community, though it contains some commented-out legacy code and hardcoded security values that represent minor technical debt.
FormKit is a form-building framework for Vue and React, organized as a monorepo of 15+ packages. The architecture is a core (framework-agnostic) node tree that manages form state, validation, schema rendering, and plugins, with separate packages for framework bindings (Vue, React, Nuxt), inputs, validation rules, internationalization (30+ locales), icons, themes (CSS, Tailwind, UnoCSS), addons (multi-step, floating labels, localStorage), a CLI for scaffolding and theme generation, and Zod integration. It uses a schema system (JSON-serializable) to define form layouts and conditional rendering, and a plugin/feature pattern for extensibility. The repository demonstrates high engineering quality: extensive test coverage (unit, type, e2e memory leak tests), well-structured abstractions (observers, message stores, composables), and cross-framework consistency. However, there are minor inconsistencies (license declared as UNLICENSED despite README claiming MIT, incomplete translations in some locales, deprecated packages like @formkit/tailwindcss, and potential brittleness in remote API dependencies in the CLI). Overall, it's a production-grade form solution with solid reusability of its core patterns.
ECC (Everything Claude Code) is a comprehensive meta-harness toolkit for AI coding assistants. It provides a universal install system, lifecycle hooks, skill management, multi-agent orchestration, evaluation harnesses, and safety validation across multiple agent IDEs (Claude Code, Codex, Cursor, Gemini, OpenCode, and others). The codebase is primarily a Node.js CLI application (published as `ecc-universal`) with secondary Python and Rust components. It includes a sophisticated hook engine (pre/post bash, session lifecycle, tool use), a manifest-driven installer with ownership tracking and path-safety guards, an eval-harness framework with deterministic replay and effect-class isolation, a skill evolution system with provenance tracking, and a multi-agent proximity coordination system. The repository also bundles a large collection of domain-specific skills (video production, compliance checking, visa document translation, financial market data) and extensive documentation translated into multiple languages. While the core architecture is well-structured and demonstrates high craftsmanship in security-critical components, the codebase suffers from some duplication (e.g., taste-application/taste-distillation skills), legacy shims, and a sprawling surface area that increases maintenance burden. The Rust TUI control-plane (`ecc2/`) is explicitly alpha. Overall, it is a production-grade, actively maintained platform with strong engineering practices in its core modules.
CowAgent is a production-grade multi-agent AI assistant platform that routes messages from 12+ IM channels (WeChat, Feishu, Telegram, DingTalk, Slack, Discord, QQ, WeCom, web console, desktop Electron app) through a modular agent core. The core implements planning, tool use (bash, file editing, browser, web search, MCP, sub-agent delegation, scheduler, memory, vision), three-tier memory with vector embeddings and markdown-aware chunking, knowledge base management, skill system with SKILL.md manifests and a skill hub, self-evolution (idle-conversation review loop), and multi-agent team orchestration with peer transport. The architecture is a modular monolith: channel adapters normalize messages into a unified ChatMessage, the Bridge dispatches to per-agent/session model resolution, the Agent protocol (Task/AgentResult/AgentAction) drives the execution loop with streaming, cancellation, and steering, and all state persists to SQLite with incremental migration. Key entry points are app.py (startup orchestration), cli/cli.py (daemon lifecycle), channel/web/web_channel.py (HTTP API and SSE streaming), and the desktop Electron client (React/TypeScript with Zustand stores). External dependencies include LLM APIs (OpenAI, Claude, Gemini, DeepSeek, etc.), IM platform webhooks/SDKs, optional voice TTS/ASR providers, and MCP servers. The codebase demonstrates strong engineering practices with extensive regression tests (200+ test files), atomic file writes, thread-safe context propagation via ContextVar, and security guards for credential paths and SSRF.