사용 방법
- 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
- 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
- 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/belokonm/claude-supercode-skills --skill django-developer시작 전 확인
- 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
- 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서
원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.
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.
