Django backend mastery: model architecture, ORM optimization, API design (DRF + Ninja), django-polymorphic patterns, MCP server construction, scientific Python integration, and Pydantic v2 mapping. Source-code-backed with Django ORM internals, DRF, Ninja, django-polymorphic, django-mcp-server, django-model-utils, django-pandas, django-filter, Pydantic v2, PydanticAI, and dj-notebook.
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.
Design Django APIs with DRF or Django Ninja: framework selection, serializers, viewsets, schemas, filtering, pagination
Bridge Django ORM with pandas/numpy/scipy: QuerySet-to-DataFrame, bulk ingest, computation pipelines
Django-Engine-Pro hub: routes to the right backend specialist (model, orm, api, polymorphic, mcp, data-bridge, pydantic)
End-of-session learning. Saves what happened, updates knowledge confidence, surfaces items for review. Run this when your work session is complete.
Build MCP servers from Django: ModelQueryToolset, custom toolsets, DRF bridge, queryset scoping, async ORM
Django API design specialist for DRF and Django Ninja framework selection, serializer design, viewset patterns, and OpenAPI schema generation. Use this agent when designing API endpoints, choosing between DRF and Ninja, designing serializers or schemas, or reviewing API architecture. <example> Context: User starting a new API for their Django project user: "Should I use DRF or Django Ninja for this API?" assistant: "I'll use the api-architect agent to evaluate the trade-offs for your use case." <commentary> Framework selection decision. API architect compares DRF vs Ninja across type safety, boilerplate, nested writes, async support, and ecosystem. </commentary> </example> <example> Context: User building a DRF endpoint with nested serializers user: "I need a serializer that handles nested creation of related objects" assistant: "I'll use the api-architect agent to design the write serializer with nested support." <commentary> Nested write serializer design. API architect knows DRF's create/update internals for nested data and the read/write serializer split pattern. </commentary> </example> <example> Context: User needs pagination strategy for a list endpoint user: "What pagination should I use for this endpoint?" assistant: "I'll use the api-architect agent to recommend a pagination strategy." <commentary> Pagination decision. API architect evaluates cursor vs offset vs keyset pagination based on data characteristics and client needs. </commentary> </example>
Django-to-scientific-Python integration specialist for QuerySet-to-DataFrame conversion, bulk ingest, computation pipelines, and memory management. Use this agent when bridging Django ORM with pandas, numpy, or scipy, or when building data pipelines that move data between Django and scientific Python. <example> Context: User needs to analyze Django data with pandas user: "How do I get my queryset into a pandas DataFrame efficiently?" assistant: "I'll use the data-bridge agent to design the extraction with proper field specification and chunking." <commentary> QuerySet-to-DataFrame conversion. Data bridge knows django-pandas, values_list patterns, and memory strategies for different data volumes. </commentary> </example> <example> Context: User needs to write computation results back to Django user: "I have a DataFrame of results I need to bulk insert into my Django models" assistant: "I'll use the data-bridge agent to design the bulk_create pipeline with NaN handling." <commentary> DataFrame-to-Django ingest. Data bridge handles NaN/None mapping, batch sizing, and transaction safety for bulk operations. </commentary> </example> <example> Context: User building a full computation pipeline user: "I need to pull observations from Django, run scipy stats, and write summaries back" assistant: "I'll use the data-bridge agent to design the extract-compute-load pipeline." <commentary> Full computation pipeline. Data bridge designs the three-phase pattern: extract with minimal columns, compute in numpy/scipy, write back with bulk_create/update_or_create. </commentary> </example>
Django MCP server construction specialist for exposing models, DRF APIs, and business logic as MCP tools. Use this agent when building MCP servers from Django, bridging DRF to MCP, or designing tool exposure patterns with queryset scoping and authentication. <example> Context: User wants to expose Django models to AI agents via MCP user: "I want Claude to be able to query my Django models via MCP" assistant: "I'll use the mcp-builder agent to design scoped ModelQueryToolsets." <commentary> MCP model exposure. Builder designs queryset scoping, authentication, and tool descriptions for safe AI agent access. </commentary> </example> <example> Context: User has existing DRF views to expose as MCP tools user: "Can I expose my existing DRF endpoints as MCP tools?" assistant: "I'll use the mcp-builder agent to bridge DRF views to MCP using decorators." <commentary> DRF-to-MCP bridge pattern. Builder knows drf_publish_list_mcp_tool and related decorators for wrapping existing views. </commentary> </example> <example> Context: User building async MCP tools with Django ORM user: "My async MCP tool is causing database errors" assistant: "I'll use the mcp-builder agent to fix sync/async ORM issues in tool functions." <commentary> Async ORM safety. Builder ensures async tools use afilter/aget/acreate instead of sync ORM, and that QuerySets are evaluated before crossing async boundaries. </commentary> </example>
Django model design specialist for inheritance strategy, field selection, managers, and migrations. Use this agent when designing Django models, choosing inheritance patterns, planning migrations, or reviewing model architecture. Triggers proactively after model code is written and reactively on model design questions. <example> Context: User needs to design a model hierarchy for a content management system user: "I need models for different content types - essays, field notes, and projects" assistant: "I'll use the model-architect agent to design the inheritance strategy and model hierarchy." <commentary> Model hierarchy design requires inheritance strategy decision. Load model-architect to evaluate abstract base vs multi-table vs proxy vs polymorphic patterns. </commentary> </example> <example> Context: User is planning a migration for an existing model user: "How do I add a polymorphic_ctype field to existing data?" assistant: "I'll use the model-architect agent to plan the migration strategy." <commentary> Migration planning for schema changes. Model-architect handles data migrations, zero-downtime patterns, and reversibility. </commentary> </example> <example> Context: User asks about field type selection user: "Should I use JSONField or normalize this into separate tables?" assistant: "I'll use the model-architect agent to evaluate the trade-offs." <commentary> Field selection decision with trade-offs. Model-architect evaluates storage, query, and maintenance implications. </commentary> </example>
Django ORM expert for complex queries, N+1 detection, performance optimization, and raw SQL. Use this agent when writing complex ORM queries, diagnosing query performance issues, or reviewing queryset patterns. Triggers on ORM performance questions, N+1 detection, and complex query construction. <example> Context: User has a slow view with many database queries user: "This view is making 200+ queries, help me optimize it" assistant: "I'll use the orm-specialist agent to diagnose N+1 issues and optimize the queryset." <commentary> Query performance problem with likely N+1 loops. ORM specialist traces ForeignKey traversals and adds select_related/prefetch_related. </commentary> </example> <example> Context: User needs a complex aggregation query user: "I need to calculate running totals with window functions" assistant: "I'll use the orm-specialist agent to build the window function query." <commentary> Advanced ORM query with Window expressions. ORM specialist knows F, Case/When, Subquery, OuterRef, and Window function patterns. </commentary> </example> <example> Context: User reviewing queryset in a DRF serializer user: "Is this queryset efficient for a list endpoint serving 1000 items?" assistant: "I'll use the orm-specialist agent to audit the queryset performance." <commentary> Queryset performance audit. ORM specialist checks for missing prefetch, unnecessary evaluation, and suggests .only()/.defer() for column projection. </commentary> </example>
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-engine-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.
Comprehensive UI/UX design plugin for mobile (iOS, Android, React Native) and web applications with design systems, accessibility, and modern patterns
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.
Multi-model consensus engine integrating OpenAI Codex CLI, Gemini CLI, and Claude CLI for collaborative code review and problem-solving.
Standalone image generation plugin using Nano Banana MCP server. Generates and edits images, icons, diagrams, patterns, and visual assets via Gemini image models. No Gemini CLI dependency required.
A growing collection of Claude-compatible academic workflow bundles. Covers scientific figures, manuscript writing and polishing, reviewer assessment, citation retrieval, data availability, paper reading, literature search, response letters, paper-to-PPTX conversion, and evidence-grounded Chinese invention patent drafting. Rules are organized as reusable skill folders with explicit workflows and quality checks.