Next.js specialist with two tracks: Development (feature implementation with source-verified APIs) and Diagnostic (error tracing through the framework's actual source code).
Build pipeline specialist for Next.js. Diagnoses failures during next build including webpack/turbopack compilation errors, module resolution failures, type errors in build context, and static generation failures. <example> Context: User's next build is failing user: "My next build fails with 'Module not found: Can't resolve fs' in an API route" assistant: "I'll use the build-diagnostics agent to trace the module resolution through handle-externals.ts." <commentary> Build-time module resolution failure — agent checks handle-externals.ts and define-env.ts for bundling decisions. </commentary> </example> <example> Context: Static generation failure user: "Getting 'Error: Dynamic server usage: headers' during next build on a page I want to be static" assistant: "I'll use the build-diagnostics agent to identify the dynamic rendering bailout." <commentary> Static generation bailout — agent checks dynamic-rendering.ts for the conditions and prerender error docs. </commentary> </example> <example> Context: Invalid next.config.js user: "Build fails with 'Invalid next.config.js options detected' but I can't figure out which option is wrong" assistant: "I'll use the build-diagnostics agent to check the config against the zod validation schema." <commentary> Config validation error — agent greps config-schema.ts for the exact zod rules and identifies the invalid option. </commentary> </example>
Data fetching, caching, mutation, and revalidation specialist for Next.js. Implements fetch patterns, Server Actions, 'use cache', ISR, and the full cache lifecycle with source-verified behavior. <example> Context: User needs to implement data fetching with proper caching user: "Set up data fetching for my blog posts with ISR that revalidates every hour" assistant: "I'll use the next-data agent to implement the correct caching pattern for Next.js 15+." <commentary> Data fetching with caching — agent verifies fetch behavior against patch-fetch.ts since defaults changed in v15. </commentary> </example> <example> Context: User has stale data issues user: "My page shows old data even after I submit the form — how do I fix the cache?" assistant: "I'll use the next-data agent to trace the cache layers and fix revalidation." <commentary> Cache invalidation issue — agent understands the 4 cache layers and where revalidation actually purges. </commentary> </example> <example> Context: User wants to use the experimental 'use cache' directive user: "How do I use 'use cache' to cache my database queries?" assistant: "I'll use the next-data agent to implement 'use cache' with proper cacheLife and cacheTag." <commentary> Experimental cache API — agent checks use-cache-wrapper.ts for exact implementation and requirements. </commentary> </example>
App Router specialist for Next.js. Diagnoses 404s, wrong page rendering, parallel route issues, intercepting route failures, navigation bugs, and router state machine problems. <example> Context: User's page returns 404 despite the file existing user: "I have app/dashboard/settings/page.tsx but it 404s when I navigate to /dashboard/settings" assistant: "I'll use the routing-debugger agent to check route resolution and file system conventions." <commentary> 404 on a valid page — agent checks file structure, conflicting routes, and route module resolution. </commentary> </example> <example> Context: Parallel routes showing wrong content user: "My @modal parallel route keeps showing the wrong content after navigating back" assistant: "I'll use the routing-debugger agent to diagnose the parallel route slot resolution." <commentary> Parallel route issue — agent checks for missing default.tsx and router state machine behavior. </commentary> </example> <example> Context: Intercepting routes not intercepting user: "My intercepting route with (.) convention isn't intercepting — it just navigates to the full page" assistant: "I'll use the routing-debugger agent to check the interception rewrite generation." <commentary> Intercepting route failure — agent greps generate-interception-routes-rewrites.ts for the rewrite logic. </commentary> </example>
Dev server specialist for Next.js. Diagnoses HMR failures, Fast Refresh loops, on-demand compilation stalls, error overlay rendering issues, and dev-specific performance problems. <example> Context: HMR stopped working in the user's Next.js dev server user: "Hot module replacement stopped working — changes don't show up without a full page reload" assistant: "I'll use the devserver-debugger agent to check the HMR connection and hot reloader." <commentary> HMR failure — agent checks WebSocket connection, hot-reloader-turbopack.ts, and on-demand-entry-handler.ts. </commentary> </example> <example> Context: Fast Refresh keeps triggering full reloads user: "Every time I save a file, the entire page reloads instead of just updating the component" assistant: "I'll use the devserver-debugger agent to diagnose the Fast Refresh full reload trigger." <commentary> Fast Refresh can only hot-update React components — non-component exports trigger full reloads. </commentary> </example> <example> Context: Error overlay not showing useful information user: "The error overlay just shows 'at ignore-listed frames' and I can't see the actual stack trace" assistant: "I'll use the devserver-debugger agent to help expose the full stack trace." <commentary> Stack trace filtering issue — agent knows about __NEXT_SHOW_IGNORE_LISTED=true and patch-error-inspect.ts. </commentary> </example>
Next.js feature implementation specialist. Builds pages, layouts, components, route handlers, and server actions with source-verified APIs. Writes production code, not prototypes. <example> Context: User wants to build a new page or feature in their Next.js app user: "Build a product detail page with dynamic OG images and add-to-cart functionality" assistant: "I'll use the next-feature agent to implement this with source-verified APIs." <commentary> Full feature implementation — agent verifies rendering strategy, component boundaries, and API contracts against source. </commentary> </example> <example> Context: User needs to set up a route with proper loading and error states user: "Create the dashboard route with streaming data and proper loading states" assistant: "I'll use the next-feature agent to design the component tree and rendering strategy." <commentary> Route implementation with rendering strategy decisions — agent checks dynamic-rendering.ts for bailout conditions. </commentary> </example> <example> Context: User needs to implement server actions user: "Add a form with server action for creating posts with optimistic updates" assistant: "I'll use the next-feature agent to implement the server action pattern correctly." <commentary> Server action implementation — agent verifies serialization rules and revalidation behavior against action-handler.ts. </commentary> </example>
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Most Claude Code plugins give you a set of slash commands and some domain knowledge. These plugins do something different: they learn.
Each plugin in this repo is a domain-specialized engineering intelligence that accumulates knowledge across sessions, grounds itself in real library source code (not training data), and coordinates with a companion chat skill on Claude.ai. The plugin implements. The chat skill plans. Over time, the plugin gets better at its job because it tracks what works, what doesn't, and what it's still uncertain about.
This is the two-surface architecture: one surface for thinking, one for building.
A typical plugin contains four layers:
Specialist agents and slash commands. Each plugin ships with 3 to 7 agents that handle specific subtasks. UI-Design-Pro has a design critic, a component builder, an accessibility auditor, an animation engineer, and a visual architect. Django-Engine-Pro has agents for model design, ORM optimization, migration planning, and MCP server exposure. Agents compose in defined sequences: you always run the stack detector before the component builder, always run the design critic after.
Source-code references. Plugins include install.sh scripts that shallow-clone real library repos into a local refs/ directory. When UI-Design-Pro needs to know how Radix handles focus restoration, it greps the actual Radix source, not its training data. When D3-Pro needs to verify a scale constructor's API, it reads the Observable source directly. This matters because training data goes stale. Source code doesn't.
Skills and decision frameworks. Static knowledge: inheritance decision tables, ORM anti-pattern catalogs, polymorphic rendering rules, animation physics constants. These encode the expert judgment that doesn't change between sessions.
An epistemic knowledge layer. This is the part that learns. Each plugin maintains a knowledge/ directory containing typed claims in JSONL, confidence scores, session logs, and (for some plugins) SBERT embeddings. Claims start as drafts. After review, they become active. Active claims carry Bayesian confidence that updates based on session outcomes: when a suggestion informed by a claim gets accepted, confidence rises; when it gets rejected, confidence drops. Over time, each plugin develops its own body of verified, weighted knowledge about its domain.
Each plugin here has a counterpart: a chat skill that runs on Claude.ai (or Claude Desktop). The division of labor is deliberate.
The chat skill handles planning, reasoning, and decision-making. When you're deciding between DRF and Ninja for an API, or choosing an inheritance strategy for a model hierarchy, or evaluating whether a component needs polymorphic rendering, the chat skill walks you through the tradeoffs and produces a structured handoff document.
The Claude Code plugin handles implementation and learning. It takes the handoff document, builds the thing, greps real source code when it needs to verify an API, logs what it tried, and updates its knowledge base with what it learned.
The chat skill never sees knowledge/claims.jsonl. The plugin never produces planning documents. Each surface does what it's good at.
| Chat Skill (Claude.ai) | Claude Code Plugin |
|---|---|
| Decision frameworks | Slash commands and agents |
| Tradeoff analysis | Source-code grepping |
| Structured handoff docs | Implementation and testing |
| Domain reasoning | Session logging and learning |
| Static (expert knowledge) | Dynamic (knowledge that evolves) |
Every plugin with a knowledge/ directory runs the same protocol:
Session start: Read manifest.json for current state. Load active claims sorted by confidence. Check tensions.jsonl for unresolved conflicts in the task's domain. Surface tensions before making decisions, not after.
During work: Track which claims informed each suggestion. Note when the user accepts, modifies, or rejects a recommendation.
Session end: Write observations to session_log/. Flag contradictions as tension signals. Note recurring patterns the knowledge base doesn't yet cover.
The knowledge types are borrowed from Theseus (a separate epistemic engine project):
Current knowledge stats across the fleet:
| Plugin | Total Claims | Active | Avg Confidence |
|---|---|---|---|
| UI-Design-Pro | 140 | 135 | 0.667 |
| Django-Engine-Pro | 111 | 29 | 0.75 |
npx claudepluginhub travis-gilbert/claude-marketplace --plugin next-proMobile app development specialist: PWA retrofitting, React Native architecture, offline-first sync, mobile API design, touch optimization, and mobile visualization adaptation.
Makes Claude Code extraordinarily good at transforming websites into applications: converting page-based Next.js sites into app-like experiences with persistent layouts, command palettes, and background sync; wrapping them in Tauri desktop shells with native OS integration; and producing architecture handoffs for native Swift/AppKit macOS apps.
Makes Claude Code genuinely good at designing knowledge-graph answer experiences with cosmos.gl on top of DuckDB-WASM, Mosaic, and vgplot. Owns the SceneDirective adapter, the three-picker ControlDock (Position, Weight, Edges), and the recipe library that turns novel ideas into usable images.
Git and deployment automation with verification at every step. Staged file review, conventional commits, pre-commit checks, push with CI/CD detection, and post-deploy health verification.
Makes Claude Code extraordinarily good at building D3 visualizations that are mathematically accurate, physically believable, and aesthetically grounded in the Mike Bostock / Observable canon.
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Intelligent draw.io diagramming plugin with AI-powered diagram generation, multi-platform embedding (GitHub, Confluence, Azure DevOps, Notion, Teams, Harness), conditional formatting, live data binding, and MCP server integration for programmatic diagram creation and management.
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
Access thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.
Upstash Context7 MCP server for up-to-date documentation lookup. Pull version-specific documentation and code examples directly from source repositories into your LLM context.
Complete developer toolkit for Claude Code