Come usare
- Copia il comando e controlla il pacchetto prima di installarlo nel tuo ambiente agente.
- Controlla strumenti, credenziali e ambienti richiesti nel documento originale.
- Descrivi input e risultato desiderato; confronta l’output con le fonti.
npx skills add https://github.com/belokonm/claude-supercode-skills --skill django-developerPrima di iniziare
- L’installazione non include abbonamenti, quote API o accesso ai file.
- Stelle e installazioni indicano attività, non un test indipendente di qualità o sicurezza.
Documento Skill originale
Contenuto dal repository con titoli, esempi, codice, tabelle, link e immagini preservati.
Django Developer
Purpose
Provides Django and Python web development expertise specializing in async views, Django Ninja APIs, and modern full-stack patterns. Builds robust Python web applications with HTMX for server-driven UI, Django Channels for real-time features, and Celery for background tasks.
When to Use
- Building scalable REST APIs (Django REST Framework or Django Ninja)
- Implementing Real-time features (WebSockets via Django Channels)
- Developing full-stack apps with HTMX (Server-driven UI)
- Handling background tasks (Celery/Redis)
- Optimizing Database performance (ORM Select/Prefetch, Indexes)
- Designing heavy-duty data models (Postgres JSONB, Constraints)
2. Decision Framework
Architecture Selection
What is the project goal?
│
├─ **API First (Headless)**
│ ├─ Type-safe / Modern? → **Django Ninja** (Pydantic-based, fast)
│ └─ Legacy / Enterprise? → **DRF** (Batteries included, heavy)
│
├─ **Full Stack (Monolith)**
│ ├─ Complex UI (SPA)? → **Django + React/Vue** (API separation)
│ └─ Dynamic but Simple? → **Django + HTMX** (Hypermedia-driven, no build step)
│
└─ **Real-Time**
├─ Simple updates? → **HTMX Polling** or **SSE**
└─ Complex/Bi-directional? → **Django Channels (WebSockets)**Async Strategy (Django 4.2+)
| Feature | Sync (WSGI) | Async (ASGI) | Recommendation |
|---|---|---|---|
| DB Queries | User.objects.get() | await User.objects.aget() | Use Async for high-concurrency I/O (proxies, chat). |
| Views | def view(req): | async def view(req): | Keep Sync for CPU-bound tasks. |
| Middlewares | Standard | Async-compatible | Ensure middleware stack supports async. |
Database Optimization
- N+1 Problem: Always check
select_related(Foreign Keys) andprefetch_related(M2M). - Indexing: Use
GinIndexfor JSONB search,BTreefor standard lookups. - Bulk Ops: Use
bulk_createandbulk_updatefor batches > 100 items.
Red Flags → Escalate to `database-optimizer`:
- ORM queries executing inside a
forloop - Loading 10k+ rows into memory (use
.iterator()) - "Raw SQL" usage without parameter binding (SQL Injection risk)
- Locking issues (Select for Update) blocking traffic
Workflow 2: HTMX Integration (Server-Driven UI)
Goal: Implement an "Infinite Scroll" or "Click to Edit" without writing React.
Steps:
- View (Python)
python
def contact_list(request):
contacts = Contact.objects.all()
# If HTMX request, return only the rows (partial)
if request.htmx:
template = "partials/contact_rows.html"
else:
template = "contact_list.html"
return render(request, template, {"contacts": contacts})- Template (`contact_list.html`)
html
<!-- Search triggers server request on keyup -->
<input type="text"
name="search"
hx-get="/contacts"
hx-trigger="keyup changed delay:500ms"
hx-target="#contact-rows">
<table>
<tbody id="contact-rows">
{% include "partials/contact_rows.html" %}
</tbody>
</table>Workflow 4: Async ORM & Views
Goal: High-throughput API endpoint using async/await.
Steps:
- View Definition
python
# views.py
from asgiref.sync import sync_to_async
async def dashboard_stats(request):
# Parallel DB queries
user_count_task = User.objects.acount()
order_count_task = Order.objects.acount()
user_count, order_count = await asyncio.gather(
user_count_task,
order_count_task
)
return JsonResponse({"users": user_count, "orders": order_count})- Middleware Compatibility
- Ensure all middlewares are async-capable (
async_capable = True). - If blocking middleware exists, wrap it in
sync_to_async.
4. Patterns & Templates
Pattern 1: Service Layer (Business Logic)
Use case: Keeping Views and Models skinny.
python
# services.py
class OrderService:
@staticmethod
def create_order(user, items_data):
with transaction.atomic():
order = Order.objects.create(user=user)
for item in items_data:
OrderItem.objects.create(order=order, **item)
# Complex logic here
PaymentGateway.charge(order)
return orderPattern 2: Custom Manager (Query Logic)
Use case: Reusable filters.
python
class PublishedManager(models.Manager):
def get_queryset(self):
return super().get_queryset().filter(status='PUBLISHED', pub_date__lte=timezone.now())
class Article(models.Model):
# ...
objects = models.Manager() # Default
published = PublishedManager() # CustomPattern 3: Async Chat (Channels)
Use case: WebSocket handling.
python
# consumers.py
class ChatConsumer(AsyncWebsocketConsumer):
async def connect(self):
self.room_name = "lobby"
await self.channel_layer.group_add(self.room_name, self.channel_name)
await self.accept()
async def disconnect(self, close_code):
await self.channel_layer.group_discard(self.room_name, self.channel_name)
async def receive(self, text_data):
# Broadcast to group
await self.channel_layer.group_send(
self.room_name,
{"type": "chat_message", "message": text_data}
)6. Integration Patterns
frontend-ui-ux-engineer:
- Handoff: Django Developer creates HTMX partials (
_card.html) → UI Dev styles them. - Collaboration: Defining "OOB Swaps" (Out of Band) for updating multiple page parts.
- Tools: Tailwind CSS.
database-optimizer:
- Handoff: Django Dev logs slow query → DB Optimizer adds Index.
- Collaboration: Analyzing
EXPLAIN ANALYZEoutput from ORM generated SQL. - Tools: Django Debug Toolbar.
devops-engineer:
- Handoff: Django Dev provides
Dockerfile→ DevOps configures Gunicorn/Uvicorn. - Collaboration: Static files handling (Whitenoise vs S3/CloudFront).
- Tools: Docker Compose.
