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.
GSD (Get Shit Done) is a mature, actively maintained meta-prompting and context-engineering system that orchestrates AI coding agents (Claude Code, OpenCode, Gemini, Codex, Copilot, Cursor, and 9+ other runtimes) through a structured milestone → phase → plan → execute → verify workflow. The system solves context decay in long AI-assisted coding sessions by maintaining a `.planning/` artifact tree (ROADMAP.md, STATE.md, PLAN.md, SUMMARY.md, VERIFICATION.md) and dispatching focused subagents with fresh 200K-token contexts for each discrete task. The codebase is a dual-package npm monorepo: a legacy CJS CLI (`get-shit-done-cc`) and a modern TypeScript SDK (`@gsd-build/sdk`) with a query-registry architecture, runtime-bridge sync primitive, and generated CJS mirrors that keep both surfaces in parity. The architecture is built around a 'thin orchestrator' pattern where slash-command entry points delegate to workflow markdown files that spawn specialized subagents (planner, executor, verifier, researcher, debugger, code-reviewer) via a registry-backed `gsd-sdk query` dispatch layer. The SDK exposes a `GSD` class that composes plan parsing, config loading, prompt building, and session running into `executePlan()` and `runPhase()` calls, with event-stream telemetry and CLI/WS transports. A `synckit`-based synchronous bridge (`executeForCjs`) lets CJS callers invoke async SDK handlers without subprocess overhead. The query registry resolves commands through a multi-strategy topology (exact, alias, dotted, spaced) with native handlers and transparent CJS fallback. What distinguishes this codebase is the obsessive engineering around installer migrations (transactional, with rollback and user-prompt resolution), cross-runtime path projection (PowerShell/cmd/Git-Bash/POSIX), adversarial parser testing (hostile frontmatter/roadmap fixtures), atomic state writes with file locking, prompt-injection scanning hooks, and a changeset-fragment workflow that eliminates CHANGELOG merge conflicts. The test suite is exceptionally thorough — 400+ test files covering mutation-resistant config validation, golden parity between CJS and SDK, security prompt injection, worktree safety, and regression coverage for 3800+ tracked issues. The system supports 15 AI runtimes with runtime-aware artifact layout, model-profile resolution, and per-agent model overrides.
Beads (bd) is a CLI-based issue tracking system designed for AI agents and developers, using Dolt as a version-controlled SQL database backend. It provides persistent, structured memory for coding agents through features like dependency tracking, workflow automation (molecules/formulas), and JSON output for scripting. The architecture features a modular Go design with clear separation between CLI, storage abstraction (supporting both embedded and server Dolt modes), workflow APIs, and extensibility systems. Key capabilities include issue lifecycle management, dependency graphs, blocking detection, telemetry, hook-based extensibility, and integrations with external trackers like Jira, GitHub, and Notion. The system emphasizes correctness through extensive conformance testing, transactional operations, and merge-safety mechanisms for distributed clones.
This repository is a local-first, source-cited knowledge base management system, delivered primarily as a Claude Code plugin and a standalone Python CLI tool. It manages Obsidian vaults with a strong emphasis on data integrity, provenance tracking, and deterministic operations. The architecture is a monolithic Python library (`claude_obsidian/`) with a formal transaction system for all vault mutations, a robust lint engine, and a retrieval pipeline (BM25 + optional semantic reranking). It features a sophisticated skill/agent framework for AI integration across multiple hosts (Claude, Cursor, Windsurf, etc.). While primarily an application, it incorporates significant data engineering and research data management (RDM) patterns. The provenance ledger system (`ledgers.py`) enforces strict schemas for sources and claims, including canonical URL handling, content-addressed identity, and evidence validation rules. The retrieval pipeline implements Anthropic's Contextual Retrieval pattern. This hybrid nature makes it a powerful tool for both knowledge management and structured research workflows. The codebase demonstrates exceptionally high craftsmanship in its transaction system, defensive I/O, and deterministic analysis tools. It is actively maintained with a comprehensive test suite and a formal release process. Its primary limitation is platform dependency on Linux/macOS for write operations (WSL required for Windows).
Orca is a production-grade Electron desktop application that functions as an integrated development environment (IDE) and orchestrator for multiple AI coding agents (Claude Code, Codex, Gemini, etc.). It manages isolated worktrees (Git, SSH, WSL) as execution environments, provides a full-featured terminal emulator (xterm-based), a browser pane, rich markdown editing, and deep source control integration (GitHub, GitLab, Linear, Jira). The system is architected as a monorepo containing the Electron desktop app (main/renderer/preload), a React Native mobile companion, a Node.js CLI, and cloud services (relay, push) for mobile pairing and notifications. Communication between processes is handled through a strict, Zod-validated RPC contract, ensuring type safety across the wire. The codebase demonstrates exceptional engineering discipline with a massive test suite (Vitest, Playwright), extensive CI/CD pipelines, and a strong emphasis on platform compatibility (macOS, Windows, Linux, WSL, Wayland). It is actively maintained with daily releases and a clear focus on managing technical debt through explicit legacy compatibility shims and migration paths.
Headroom is a context optimization layer for LLM applications that reduces token usage by 50-90% through intelligent compression, caching, and memory systems. It provides a transparent proxy between LLM clients (like Claude Code, Cursor, etc.) and LLM providers (Anthropic, OpenAI, etc.), implementing CCR (Compress-Cache-Retrieve) for lossless compression with retrieval capability. The system features a hybrid polyglot architecture with a Rust-based high-performance proxy core, Python ecosystem for extensibility, and TypeScript SDK. Key capabilities include agent wrapping, cross-agent memory using Qdrant/Neo4j, observability through metrics and dashboard, and a learning system that analyzes interaction patterns to generate optimization rules. Deployment options include Docker, system services, and direct execution.
Humanizer is a skill (prompt) for AI agents that rewrites AI-generated text to sound human-written without altering factual content. It is built on Wikipedia's 'Signs of AI writing' guide and provides 26 numbered patterns grouped into six categories (staging, rhythm, inflation, formatting, leftovers, wrong reader). The skill is distributed as a single markdown file (SKILL.md) with YAML metadata, installable via plugin manifests for Claude Code, Cursor, and other agents through the Skills CLI. The repository also includes a validation script, issue templates, and CI workflows to maintain consistency across package files. While not a traditional software application, it functions as a tool that agents execute, with clear entry points (/humanizer command) and a well-defined workflow (mark tells, draft rewrite, check, finalize). The codebase is meticulously maintained with active issue triage, regular releases, and automated validation.
This repository is a production-grade meta-framework for building and managing AI agent plugins across multiple coding assistants (Claude Code, Codex, Cursor, OpenCode, Gemini, Copilot). It establishes a single source of truth in Markdown (`plugins/`) that is compiled into harness-specific artifacts via Python adapters. Key features include a security layer using Cedar policies for tool-call authorization and signed audit receipts, a project management system (`conductor`) for track-based development, and a quality evaluation framework (`plugin-eval`) using static analysis and LLM-based scoring. It solves the fragmentation problem of AI agent ecosystems by enforcing portability and governance.
CodeBurn is a local-first, cross-platform observability and cost management tool for AI coding assistants. It reads session logs from 40+ AI tools (Claude Code, Cursor, Copilot, Codex, Gemini, etc.) directly from the user's local disk, parses them, and attributes costs using a bundled pricing engine with fallbacks. The architecture is a modular monolith with a core TypeScript CLI engine and multiple platform-specific frontends (Electron desktop, Swift macOS menubar, Tauri Windows/Linux tray, VS Code extension, MCP server, and GNOME extension). The codebase demonstrates exceptional engineering discipline. It features a sophisticated versioned cache with cross-process locks and progressive hydration, a clean provider adapter pattern for ingesting heterogeneous data sources, and a robust quota monitoring system with strict error handling and credential safety. The test suite is extensive, covering parser edge cases, cache correctness, and cross-platform parity. The project is actively maintained with frequent releases and a large community (11k+ stars). The primary risk is the volatility of the external AI tool APIs it depends on for quota tracking and log formats, but the code is structured to handle this through its adapter pattern and comprehensive testing. It requires Node.js 22.13+.
Understand Anything is a developer tool that analyzes codebases to create interactive knowledge graphs for code comprehension and onboarding. It combines deterministic static analysis (using tree-sitter) with LLM-powered semantic understanding to build explorable graphs of files, functions, classes, dependencies, and business domains. The system features a multi-agent pipeline for analysis, incremental updates via fingerprinting, and a React/Vite dashboard for visualization with guided tours, semantic search, and diff impact analysis. The architecture follows a monorepo structure with pnpm workspaces separating core analysis engine, dashboard UI, and plugin interface. Key capabilities include language-agnostic structural analysis across 30+ programming languages, business domain extraction, knowledge base analysis (Obsidian/Logseq-style wikis), and multi-platform support for AI coding assistants (Claude Code, Codex, Cursor, Copilot). The system operates offline for structural analysis while optionally leveraging LLMs for enrichment, with persistence to a .ua/ directory for team collaboration via version control.
CareerOps is a local-first, AI-assisted job search automation platform. It scans 100+ ATS job boards and aggregators (Greenhouse, Lever, Ashby, Workday, iCIMS, PeopleSoft, 55+ providers) through a standardized provider abstraction, evaluates each posting against the user's CV by delegating to AI coding CLIs (Claude Code, Codex, Gemini, OpenCode, etc.), emits structured A–H evaluation reports with 1–5 fit scores, generates ATS-optimized CV PDFs and cover letters, and tracks the full application lifecycle in a Markdown/TSV data store. It ships three surfaces: a Node.js CLI core (~150 .mjs modules), a Next.js 16 web dashboard, and a Go Bubble Tea TUI. All data remains on the user's machine; nothing is ever auto-submitted—a human presses send. The evaluation, scoring, and pattern-analysis features (funnel velocity, repost detection, calibration against outcomes) are product features, not research artifacts, so the repo is classified as an application despite these analytical components. Architecturally, this is a monorepo spanning three runtimes that share a flat-file data layer coordinated by cross-process file locks (SHA256-derived lock directories compatible between Go and Node). Its standout engineering includes a provider registry pattern for ATS integrations, a plugin engine with mandatory human-in-the-loop enforcement, capability-fenced CLI spawning for AI agents (read-only/web-search-only modes with per-CLI fencing probes), atomic write-with-backup for every user-layer file, and a 400+ file test suite including byte-level parity tests that keep web-side algorithm mirrors aligned with core logic, SSRF-hardening tests across all providers, and cross-platform contention tests. The repo also demonstrates unusually mature governance: plugin registration with pinned SHAs, direction gates in CI, localization drift checks for 16 languages, and a self-updater with rollback. Weaknesses: the Go/Node split duplicates tracker parsing logic (mitigated by shared header-alias tables but still a maintenance burden), parsing is regex-heavy over markdown tables with many special-case bugs, and rapid feature expansion has produced visible bloat—dozens of AI-provider-specific eval scripts, many localized mode trees, and extensive one-off migration scripts. The external ecosystem (ATS site markup, AI CLI permission models) shifts constantly, requiring the active dead-board pruning and fencing probes visible in the codebase. Overall this is a well-crafted, heavily tested local-first application with several genuinely reusable security and concurrency patterns, held back from exceptional by its dual-runtime duplication and feature sprawl.
planning-with-files is a persistent, file-based task-planning system for AI coding agents. It maintains task_plan.md, findings.md, and progress.md on disk and wires into agent lifecycle hooks (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, PreCompact, Stop) across Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, Pi, Hermes, and a dozen other assistants, re-injecting plan context into the model's context window on every turn. Plans survive context loss, /clear, compaction, and crashes; a session-catchup mechanism recovers prior transcripts. A v3 gated mode can block the agent from stopping until plan phases complete, backed by an append-only JSONL run ledger, stall detection, and SHA-256 plan attestation that makes hooks refuse to inject tampered content. Architecturally it is a distribution hub rather than a single application: a canonical skill under skills/planning-with-files is mirrored byte-identical into 15+ IDE-specific directories, with native TypeScript plugins (OpenCode, Pi, DSH), a Python plugin (Hermes), and shell/PowerShell hook dispatchers. Plan resolution is a fail-closed chain (PLAN_ID env → .active_plan pointer → newest plan dir → legacy root) guarded by slug validation, containment checks, symlink/junction rejection, and strict PWF_PLAN_ROOT pinning. The engineering is unusually rigorous for an agent-skill repo: 400+ pytest tests, byte-parity tests between shell/PowerShell/Python/TypeScript twins, a PATH-stub BSD userland simulation to catch GNU-only flags that silently fail on macOS, and heavy Windows PowerShell 5.1 / Git Bash portability hardening. Non-obvious patterns include KV-cache-stable injection output (no timestamps or free text in summaries, wall-clock normalization to T00:00:00Z) and an mtime-keyed attestation cache for performance. The repository is a developer tool, not a data/research project; although it ships benchmark and eval documentation (assertion pass rates, recovery-turn comparisons), those are verification evidence for the skill, not analysis artifacts. It is actively maintained at v3.24.0 with recent commits, 4 open issues, and 100+ releases; technical drift is low, with the main maintainability risk being deliberate duplication across 20+ canonical mirrors, mitigated by sync-ide-folders.py and parity tests but still a possible source of silent drift.
Gentle-AI is a CLI-driven application that manages AI coding agents through installation, configuration, and review workflows. It provides a deterministic engineering environment with features like persistent memory (Engram™), receipt-driven development (RDD) for verifiable code reviews, and telemetry collection. The architecture is modular, separating concerns into CLI commands, agent adapters, components (like Skills and Context7), review transaction logic, state management, and a text-based user interface. The system interacts with external AI agents (Claude Code, OpenCode, Cursor, etc.) via adapter patterns, manages state in $HOME/.gentle-ai, and supports cross-platform operation (Linux, macOS, Windows). Key entry points include the gentle-ai CLI command and TUI screens for interactive workflows.
AxonHub is a production-grade, multi-provider LLM API gateway that routes, transforms, and manages requests to a wide range of AI providers (OpenAI, Anthropic, Gemini, DeepSeek, xAI, and 60+ others). It provides a unified API surface for chat completions, embeddings, moderations, audio, images, and video generation, with sophisticated features like load balancing (latency-aware, weighted round-robin, circuit breaker), per-channel rate limiting, provider quota enforcement, streaming, and reasoning token handling. The backend is written in Go using Gin, Ent ORM, gqlgen, and Uber Fx for dependency injection, supporting PostgreSQL, MySQL, and SQLite with automatic migration. The frontend is a comprehensive React/TypeScript SPA (Vite, TanStack Router/Query, Tailwind, shadcn/ui) that provides administration of channels, models, API keys, users, roles, projects, and system settings. It includes analytics dashboards, request tracing, usage logs, and OIDC SSO. The system is designed for multi-tenancy with fine-grained RBAC (scope-based permissions) and privacy policies enforced at the Ent ORM layer. Deployment is supported via Docker, Docker Compose, and Helm charts. The codebase exhibits strong engineering practices: extensive unit and integration tests (including race-condition tests and E2E Playwright tests), pipeline middleware for request transformation, generic caching abstractions, stream processing utilities, and a Zanzibar-inspired authorization framework. While there are minor issues (duplicate utility packages, a typo in a folder name, and some frontend boilerplate repetition), the overall architecture is clean, modular, and well-documented. The project is actively maintained with frequent commits, issue triage, and a clear release process.
CLIProxyAPI is a sophisticated Go-based proxy/gateway service that acts as an intermediary between clients and multiple AI service providers (OpenAI, Claude, Gemini, Codex, xAI/Grok, etc.). It handles authentication, request/response translation, routing, and management of AI API interactions. The system features a modular architecture with distinct layers for server handling, authentication, execution, translation, plugins, and configuration. It provides both REST and WebSocket interfaces, includes a terminal UI for interactive management, and offers extensibility through a plugin system. The codebase demonstrates strong engineering practices with comprehensive testing, clear separation of concerns, and reusable components.
Oh-My-ClaudeCode (OMC) is a multi-agent orchestration layer for Claude Code, Anthropic's AI coding assistant. It extends Claude Code with a plugin system, custom MCP tools, a team collaboration engine, a real-time HUD, and a rich hook system. The system is implemented in TypeScript and runs as a CLI tool (`omc`), an npm package (`oh-my-claude-sisyphus`), and a Claude Code plugin. It manages autonomous coding pipelines (autopilot, ralph), multi-worker team sessions via tmux, skill learning and injection, and provides extensive tooling including LSP integration, AST analysis, Python REPL, and git-based checkpoints. Architecturally, OMC is a modular monolith with clear separation: a CLI entry point (Commander-based), a hook registry with ~20+ lifecycle hooks (session-end, pre-tool-use, persistent-mode, etc.), a team subsystem with state machines and tmux-based worker management, a HUD rendering engine, and a standalone MCP server exposing 33+ tools. The system integrates with multiple AI providers (Claude, Codex, Gemini, Grok, Cursor) and git hosting providers (GitHub, GitLab, Azure DevOps, Bitbucket, Gitea). External dependencies include `@anthropic-ai/claude-agent-sdk`, `@modelcontextprotocol/sdk`, `better-sqlite3`, `zod`, and `commander`. Key data flows include: user input → CLI or Claude Code hook → hook dispatcher → feature modules (autopilot, team, skills) → tool execution → state persistence (filesystem, SQLite). The system maintains extensive state on disk (`.omc/state/`, session transcripts, team events, skill files) and uses file-based locking for concurrency safety. The JEV shadow judgment system provides non-blocking evaluation of heuristic decisions against an external API for quality monitoring. The codebase demonstrates strong engineering practices: extensive test coverage (~3000+ tests), modular architecture with clear interfaces, atomic file operations, and security-conscious utilities (SSRF guard, token redaction, path traversal prevention). It is actively maintained with frequent releases and responsive issue triage.
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.
This repository implements a 'Repository Harness'—a Rust-based CLI framework designed to make software codebases legible and operable for AI agents. It functions as a control plane for agent-assisted development, managing project state (stories, decisions, traces) through a combination of Git-native documents and a durable SQLite layer. The system enforces architectural rules and invariants via mechanical validation rather than process bureaucracy, distinguishing between a generic 'Core' payload and product-specific 'Consumer' work (e.g., Symphony). Key capabilities include self-updating binaries, semantic changeset replay for auditability, and explicit agent skills for onboarding and auditing. Architecturally, the codebase follows a clean separation of concerns with a Rust workspace containing `harness` (core logic) and `harness-cli` (interface). It utilizes a repository pattern to decouple business logic from database access, implementing transactional logging via JSONL changesets that support idempotent replay. The tool manages its own lifecycle through a robust installer that supports cross-platform profiles (Core vs. Core+CLI) and handles file conflicts via deterministic three-way merges. Evidence capsules and epoch fencing ensure data integrity during agent interactions and state transitions. The project demonstrates a high level of engineering maturity through its focus on reproducibility and trust boundaries. It includes extensive documentation (ADRs, execution plans, stories) and a comprehensive test suite covering installer contracts, changeset rebuilds, and boundary checks. The separation of the 'Symphony' product into a distinct repository while retaining protocol primitives in the core highlights a mature approach to library vs. application boundaries.
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.