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.
Electron React Boilerplate is a foundation for building scalable desktop applications using Electron, React, TypeScript, and Webpack. It provides a complete architecture with separate main and renderer processes, secure IPC communication via contextBridge, automated build and packaging workflows, and follows Electron security best practices. The boilerplate includes development features like hot reloading and debugging tools, as well as production capabilities such as auto-updating, code signing, and notarization support.
This repository is a reference architecture for building production-ready React applications, implemented as a monorepo containing three distinct application templates: Next.js App Router, Next.js Pages Router, and Vite. It serves as a comprehensive guide for scalable project structure, demonstrating best practices in state management (Zustand for client state, TanStack Query for server state), testing (Vitest, Playwright, MSW), and security (JWT, RBAC). The codebase prioritizes strict TypeScript usage, unidirectional data flow, and feature-based colocation. The system functions as a boilerplate and educational tool rather than a standalone product. It provides a complete development environment including UI component libraries (Radix UI + Tailwind), form handling (React Hook Form + Zod), and API abstraction layers. The architecture is designed to be copy-pasted into new projects, with the three app implementations serving as comparative examples for different React rendering strategies. Key operational patterns include a centralized API client with Axios interceptors for authentication and error handling, a mock backend service using MSW and @mswjs/data for local development and testing, and a robust authorization system that enforces role-based access control at the component and route levels. The codebase is heavily instrumented with tests and documentation to ensure maintainability and adherence to the defined architectural standards.
This repository is a full-stack monorepo template for building SaaS applications using React 19, tRPC, and Cloudflare Workers. It features an edge-native architecture with three Workers (web router, app SPA, and API server) connected via service bindings. The template includes integrated authentication (Better Auth with email OTP, passkey, Google OAuth), multi-tenancy, Stripe billing, transactional emails (via Resend), file uploads to Cloudflare R2, and a Neon PostgreSQL database accessed through Drizzle ORM with Hyperdrive connection pooling. Key components include a reusable shadcn/ui component library, a typed WebSocket protocol package, and isolated database testing utilities.
This is a comprehensive Cookiecutter template for generating production-ready Python projects. It is not a running application itself but a project generator that produces applications, libraries, or services based on user-selected features. The template includes sophisticated post-generation hooks that surgically remove unused files and configure dependencies, Docker Compose services, CI/CD workflows, and documentation based on the chosen options. It enforces modern Python practices: uv for package management, Ruff for linting/formatting, mypy for type checking, pytest for testing, and Pydantic Settings for configuration. The generated projects can include FastAPI, Celery, SQLAlchemy, QuasiQueue, aiocache, Jinja2, Typer CLI, Docker, and GitHub Actions. The template itself demonstrates high craftsmanship with clean Jinja2 templating, conditional logic, and a well-organized file structure. It is actively maintained and uses current tooling (uv, Ruff, etc.), indicating low technical drift.
Ant Design Pro is an enterprise-grade React admin dashboard starter/template, not a data research repository. It provides a production-oriented SPA scaffold built on Umi Max 4, React 19, Ant Design 6, and ProComponents, with pre-built pages for authentication, dashboards, forms, lists, profiles, results, exceptions, account management, and an AI chatbot. The code is organized as a classic frontend application: `src/app.tsx` composes runtime configuration, `config/routes.ts` declares routing, pages are co-located with services, mock data, styles, and tests, and `src/services/` contains generated API client code. There is no real persistence; all data flows through mock handlers during development or through the bundled Cloudflare Worker backend in deployed demos.
This is a production-ready Node.js/Express web application boilerplate designed to jumpstart hackathon projects. The codebase implements a complete user authentication system supporting local email/password, OAuth 2.0/OAuth 1.0a (10+ providers including Google, Facebook, GitHub, Discord, Microsoft), WebAuthn passkeys, and two-factor authentication (TOTP + email). It includes session management with MongoDB, CSRF protection, rate limiting, and custom security measures like timing-safe token comparisons and IP-bound token consumption. Beyond auth, it ships working demos for ~20 third-party API integrations (Stripe, Twilio, GitHub, NYT, Wikipedia, etc.) and AI features powered by LangChain and Groq, including a ReAct agent with SSE streaming, a RAG pipeline with vector search, and LLM-based classification/vision. The repository also provides a sophisticated Playwright-based e2e testing framework using nock-recorded HTTP fixtures, enabling deterministic offline tests without live API keys. All features are organized as deletable modules with a removal checklist to facilitate trimming for production use.
Bolt CEP is a comprehensive boilerplate for building Adobe Common Extensibility Platform (CEP) extensions using modern web technologies. It provides a unified development experience for creating extensions that work across Adobe applications like Photoshop, Illustrator, Premiere Pro, and After Effects. The system features a monorepo structure containing the core boilerplate, a project creation CLI (create-bolt-cep), and a specialized Vite plugin (vite-cep-plugin) that handles CEP-specific build tasks. Developers can choose between React, Vue, or Svelte for their frontend framework while writing type-safe ExtendScript that compiles down to ES3 for CEP compatibility. Key innovations include an end-to-end type-safe bridge between CEP JavaScript and ExtendScript (via evalTS/listenTS/dispatchTS), automated ZXP packaging with cross-platform signing support, and intelligent asset handling. The build process leverages Vite for fast HMR during development and Rollup for producing CEP-compatible ExtendScript bundles.
django-init is a cookiecutter template for generating Django-based REST API projects. It provides a comprehensive starting point with Django 4.1, Python 3.9, Poetry dependency management, Django REST Framework, and optional features like Celery, GraphQL, ASGI, Docker, and various deployment configurations. The template generates projects with custom user models, JWT authentication, proper API versioning, and testing setup. What distinguishes this template is the quality of its reusable components in the base/ directory, particularly the custom DRF mixins for multiple serializers and per-action permissions, specialized routers for singleton resources, and thoughtful exception handling and response classes that demonstrate deep understanding of Django REST Framework's architecture.
This is a boilerplate project for mobile app and browser test automation using Appium and WebdriverIO v9. It provides a comprehensive set of example tests, page/screen objects, reusable helpers, and configuration files for running tests locally or on cloud providers (Sauce Labs, BrowserStack, TestingBot, LambdaTest). The codebase demonstrates cross-platform testing patterns for iOS and Android, including biometric login, deep link navigation, drag-and-drop, swiping, form interactions, and WebView handling. It is well-structured with TypeScript, async/await, and the Page Object Model. The project is actively maintained with recent commits and up-to-date dependencies, making it a solid starting point for teams implementing mobile automation.
This repository is a production-grade FastAPI boilerplate (named 'Fastro') designed to accelerate building SaaS backends. It provides a complete, modular architecture with three layers: infrastructure (config, caching, rate limiting, auth, logging, database), interfaces (REST API, admin panel), and vertical-slice modules (user, tier, API keys, rate limits). The codebase is fully async, uses SQLAlchemy 2.0 with `MappedAsDataclass`, Pydantic v2, and FastCRUD for generic CRUD operations. Authentication is session-based via the external `crudauth` library, with server-side sessions, CSRF, OAuth (Google wired), and API key support. Caching and rate limiting follow a provider pattern with swappable Redis/Memcached backends. The repo also includes a CLI tool (`bp`) with plugin discovery for commands and features, a multi-stage Dockerfile, Alembic migrations, and extensive documentation (though some docs describe aspirational features not yet implemented). A paid fork (FastroAI) adds payments, email, and frontend, but the free boilerplate is self-contained and functional.
Nellavio is a production-grade, open-source Next.js dashboard starter designed for building modern SaaS products, internal tools, and admin panels. It provides 90+ reusable UI components, 60+ chart variations, authentication (Better Auth) with RBAC, i18n (next-intl), theme switching, and extensive data visualization pages (analytics, orders, customers, products, calendar, charts showcase). The architecture follows App Router with clear separation: server components for data fetching (Apollo Client GraphQL with mock fallback), client components for interactive views, Zustand for global state, and TanStack Table for data tables. The codebase is well-tested with Vitest, Storybook, and CI/CD (GitHub Actions). Despite some hardcoded demo data and recent migrations (Clerk→Better-Auth, Tremor→Recharts), the engineering practices are strong, making it a solid foundation for bootstrapping dashboard-centric applications.
This repository is a boilerplate for building desktop applications using Electron, Vue 3, and Vite. It provides a pre-configured setup that includes a main process (handling application lifecycle and window creation), a preload script (securely exposing Electron and Node.js APIs to the renderer via contextBridge), and a renderer process (built with Vue and Vite). The project includes demos showing inter-process communication (IPC) and direct Node.js usage in the renderer. The architecture follows the standard Electron model, with the main process managing the application lifecycle and the renderer process running the Vue application. Vite is used as the build tool for all processes (main, preload, and renderer), leveraging vite-plugin-electron to handle Electron-specific build configurations such as sourcemaps, minification, and dependency externalization. The preload script exemplifies best practices by using contextBridge to expose only the necessary IPC methods, avoiding the security risks of enabling nodeIntegration or disabling contextIsolation. While the project is relatively simple and serves as a starting point, it contains several reusable patterns and configurations. Notably, the Vite configuration (vite.config.ts) demonstrates a non-obvious but effective way to set up Vite for Electron builds, including separate configurations for the main and preload processes. The preload script also contains reusable DOM utility functions (domReady and safeDOM) and a secure pattern for exposing Electron APIs. Overall, the boilerplate is well-structured, adheres to modern Electron and Vue practices, and provides a solid foundation for building Electron applications with Vue and Vite.
This is a modern Next.js 16 starter template using the App Router, designed to jumpstart full-stack web applications. It provides a production-ready monolith with authentication via NextAuth (GitHub provider), payment processing through Stripe subscriptions, and a PostgreSQL database layer using Drizzle ORM and Neon serverless. The application includes internationalization (i18n) with next-intl, dark mode theming, custom fonts, and standard SEO features like sitemap and robots.txt. The codebase demonstrates disciplined engineering with TypeScript, Zod environment validation, Biome linting, Husky git hooks, and both unit (Jest) and end-to-end (Playwright) testing. While functionally complete and well-structured, it is fundamentally a starter kit composed of framework boilerplate and standard integrations, without innovative or deeply reusable custom abstractions beyond what is typical for such templates.
This is a production-oriented full-stack SaaS starter kit (not a data/research project). It is a monorepo template pairing a Next.js web app (landing page, auth flow, account dashboard, marketing sections) with a Flutter cross-platform app (iOS/Android/macOS/Windows/Linux/web) on top of a shared Supabase backend. The backend is a Postgres schema (users, customers, products, prices, subscriptions, invoices) protected by row-level security, plus Deno edge functions that orchestrate Stripe Checkout sessions and process Stripe webhooks. PostHog handles analytics on both frontends, Loops.so handles transactional email, and an optional Monero cryptocurrency payment variant can be toggled in via patch scripts, giving the template two billing backends.
Materio is a free admin dashboard starter template built on Next.js 14 App Router, MUI v5, and Tailwind CSS, published by ThemeSelection. It ships as two parallel, functionally identical codebases: javascript-version/ and typescript-version/. Everything in the repo is static UI - hardcoded demo data, mock ApexCharts, placeholder auth forms - there is no API layer, database, or authentication logic. Its job is to be a polished starting point for admin applications, and it executes that role well: an extensive per-component MUI theme override system, a custom collapsible vertical menu subsystem, and a cookie-persisted settings context for dark/light mode. Architecturally it follows Next.js App Router conventions: root layout (app/layout.jsx), a dashboard layout that wraps the VerticalLayout shell (navigation, navbar, footer), and a blank layout for login/register/error pages. The most interesting engineering lives in src/@menu (a self-contained vertical navigation layer with context-driven collapse/expand and breakpoint behavior), src/@core/theme (dozens of isolated MUI component overrides), and a few genuinely reusable React hooks (useObjectCookie, useImageVariant). All dashboard data is fabricated; adopters must wire real data and backend logic themselves. The template is actively maintained (last commit March 2026, one open issue, automated issue triage workflows). Drift risks are version pinning to Next.js 14 / MUI v5.15 and the maintenance cost of keeping JS and TS variants in sync.
This is a Vue 3 Single-Page Application (SPA) that provides an interactive form-based interface for generating Markdown badges using the shields.io service. The application allows users to generate repo metadata badges, generic static badges, package version badges, dynamic data badges, image markdown/HTML, and a catalogue of pre-made badges. The code is written in TypeScript with a clean separation of concerns: core logic modules handle badge generation and URL construction, Vue components manage UI, and a simple store persists user preferences via localStorage. The architecture is monolithic with client-side routing via Vue Router. The project demonstrates solid software engineering practices with comprehensive unit tests, a Makefile for common tasks, and GitHub Actions CI/CD for linting, testing, and deployment. While the codebase is well-structured and maintainable, it relies on the deprecated Vue CLI and some packages are several major versions behind (e.g., TypeScript 4.6, ESLint 8), indicating moderate technical drift. The application is actively maintained with recent commits and a clear release process.
This repository is a personal portfolio website built with Next.js 14, React, and TypeScript. It features a blog section with MDX-powered articles sourced via Contentlayer, a projects showcase, and a responsive UI built with Chakra UI. The application uses static site generation (SSG) for optimal performance and includes client-side search functionality for articles and projects. Key architectural elements include the Next.js app router, file-based routing, and a modular component structure separating layouts, UI components, and data utilities. The site implements modern web development practices such as dark/light theme support, image optimization with blur placeholders, analytics integration (Vercel and Google Analytics), and error monitoring via Highlight. Content is sourced from MDX files in the data/articles directory and static JSON files for projects and publications. The build process leverages Next.js's incremental static regeneration (ISR) capabilities through Contentlayer, ensuring content updates without full rebuilds. Notable reusable components include a custom BlurImage component that enhances perceived performance by showing a blurred placeholder during image loading, and a Callout component for styling informational, warning, and error messages in MDX content. Both components are decoupled from specific business logic and demonstrate solid encapsulation patterns suitable for extraction into other projects.
This repository is a modern PHP package skeleton created by Nuno Maduro. It provides a minimal, opinionated starting point for building PHP libraries, featuring a pre-configured toolchain including Laravel Pint for code style, Pest for testing, PHPStan for static analysis, and Rector for automated refactoring. The actual source contains only a placeholder Example class to verify the setup, while the value lies in the well-organized directory structure, Composer scripts, GitHub Actions workflows (testing across OS and dependency versions), and configuration files that enforce high code quality standards. It is designed to be cloned via `composer create-project` and immediately used for new package development. The repo is actively maintained with no open issues, modern dependency versions, and comprehensive CI coverage.
This is a production-ready, multi-tenant SaaS starter kit built with Next.js (Pages Router), NextAuth.js, Prisma ORM (PostgreSQL), and Tailwind CSS. The system provides comprehensive enterprise features: email/password authentication, magic link, OAuth (Google, GitHub), SAML/SSO via BoxyHQ Jackson, directory sync (SCIM), webhooks via Svix, audit logging via Retraced, Stripe billing, API keys, and team-based role management (RBAC). The architecture follows a monolith with API routes under /pages/api, middleware for session validation, and a component-based frontend. Data flows center around team creation and management: users register (or SSO), create or join teams via invitations, then configure team-level SSO, directory sync, webhooks, billing, and API keys. The codebase demonstrates solid engineering practices with Zod validation, reusable UI components, and a clear separation of concerns, but shows signs of feature creep and some legacy patterns (e.g., Pages Router). It is well-suited for developers building a SaaS platform who need a jump-start on authentication, team management, and enterprise integrations.