Full-stack Django development toolkit. Skills for backend architecture (models, views, APIs, auth, deployment) and frontend integration (HTMX, Alpine.js, Tailwind CSS, D3, django-cotton components, design systems). Commands for scaffolding projects, apps, APIs, and components. Agents for architecture review, API design review, frontend integration review, migration safety, and performance profiling.
Scaffold DRF API endpoints for a Django model - ViewSet, serializers, URLs, permissions, and tests
Scaffold a new Django app inside an existing project with proper wiring
Scaffold a django-cotton component with props, slots, styling, and optional Alpine.js behavior
Scaffold a new Django project with production-grade structure
Generate Django models from a domain description with proper fields, indexes, constraints, and managers
Use this agent to review Django REST Framework API code for design quality, security, and conventions. It checks serializer patterns, endpoint design, permissions, throttling, pagination, error handling, and versioning. Invoke it when building or reviewing API endpoints. <example> Context: Developer has created new DRF ViewSets and serializers for a content API. user: "Review the API layer for the content app." assistant: "I'll review the serializers, ViewSets, URL router config, permissions, and pagination for the content API." <commentary> The agent reads serializers.py, api_views.py (or views.py), urls.py, and permissions.py to check for common API anti-patterns like N+1 serializer queries, missing pagination, overly permissive permissions, and inconsistent response shapes. </commentary> </example> <example> Context: A team is adding filtering and search to existing API endpoints. user: "Check if our API filtering follows best practices." assistant: "I'll review the filter backends, search fields, and queryset optimization to ensure filtering is efficient and consistent." <commentary> The agent checks django-filter integration, search_fields configuration, and whether filtered querysets use appropriate indexes and select_related/prefetch_related. </commentary> </example> <example> Context: Developer wants to ensure API authentication and throttling are properly configured. user: "Audit the API auth and rate limiting setup." assistant: "I'll review DEFAULT_AUTHENTICATION_CLASSES, permission policies, throttle rates, and CORS configuration across settings and individual views." <commentary> The agent checks settings.py REST_FRAMEWORK config, per-view permission overrides, throttle scope assignments, and CORS headers to ensure the API is secure by default. </commentary> </example>
You are a Django architecture reviewer specializing in production-grade Django application quality. You review both backend (models, views, settings, APIs) and frontend (templates, components, interactivity, design tokens) to ensure the entire stack is well-architected.
Use this agent to review Django frontend code for template quality, component conventions, interactivity patterns, and accessibility. It checks template inheritance, django-cotton components, HTMX usage, Alpine.js patterns, Tailwind CSS conventions, design system tokens, and D3 chart integration. Invoke it when building or reviewing templates, components, or interactive features. <example> Context: Developer has built an essay listing page with HTMX-powered search and filtering. user: "Review the frontend for the essay list page." assistant: "I'll review the template inheritance, HTMX partial pattern, filter form, Cotton components, and Tailwind styling for the essay list." <commentary> The agent reads the full page template, its HTMX partials, any Cotton components used, and the associated view to check for proper partial extraction, CSRF handling, swap targets, and debounce on search inputs. </commentary> </example> <example> Context: A team is building reusable Cotton components for their design system. user: "Check our Cotton component library for consistency." assistant: "I'll review component definitions for proper c-vars defaults, slot usage, attribute proxying, naming conventions, and design token usage." <commentary> The agent reads all files in templates/cotton/, checks for consistent prop naming, proper {{ attrs }} passthrough, semantic color tokens instead of hardcoded hex values, and proper Alpine integration using double-colon syntax. </commentary> </example> <example> Context: Developer is adding interactive charts to a publishing pipeline dashboard using D3 and Alpine. user: "Review the dashboard frontend - charts, interactivity, and data loading." assistant: "I'll review the D3 chart modules, Alpine data controllers, json_script data handoff, responsive SVG patterns, and template integration." <commentary> The agent checks that data is passed via json_script (not {{ data|safe }}), SVGs use viewBox for responsiveness, Alpine controls chart parameters, and D3 modules are organized in static/js/charts/. </commentary> </example>
You are a Django migration safety reviewer. Your job is to catch deployment-breaking migration issues before they reach production. You understand that migrations run against live databases with real data, often during deployments where downtime must be minimized.
You are a Django performance profiler. You analyze views, querysets, serializers, and templates to find performance bottlenecks and provide specific, actionable fixes. You think in terms of query counts, index coverage, and data flow from database to response.
Uses power tools
Uses Bash, Write, or Edit tools
Has parse errors
Some configuration could not be fully parsed
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 django-designMobile 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.
Harness-native ECC operator layer - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
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