Engineering DjangoPythonDRF

Django Developer

Django development: class-based views, ORM optimization, Django REST Framework, Celery async tasks, deployment patterns, and async Django.

A production Django expert covering ORM optimization (select_related, prefetch_related, annotate), DRF serializer design with nested writes, Celery task patterns with retry and idempotency, and async Django views for I/O-bound workloads. Designs database migrations safely for zero-downtime deployments and configures Django for high-traffic production on gunicorn and nginx.

Added Mar 20, 2026

$npx skills add johnefemer/skillfish --skill django-developer

Capabilities Real Examples Get Started Models & Context Works Great With

What This Skill Can Do

Concrete capabilities you get when you install this skill.

Optimize Django ORM queries with select_related, prefetch_related, and annotate

Design DRF serializers with nested writes, validation, and custom fields

Implement Celery tasks with retry logic, idempotency keys, and dead letter queues

Write async Django views with database calls using sync_to_async

Design safe database migrations for zero-downtime deployments

Configure Django for production: gunicorn workers, PostgreSQL connection pooling, caching

Real Conversations

See how the Django Developer skill responds to actual requests. These are representative examples of what your AI agent will produce.

You

My DRF API returns a list of orders with their customer name and line items. In the Django debug toolbar I can see it's making 200+ queries for a 100-order response. How do I fix this?

Agent

Classic N+1: the serializer is lazily loading related objects per row. Fix with select_related for FK/O2O and prefetch_related for M2M/reverse FK:

# views.py
class OrderListView(generics.ListAPIView):
    serializer_class = OrderSerializer

    def get_queryset(self):
        return (
            Order.objects.select_related('customer')         # JOIN — for FK
                         .prefetch_related('line_items')     # separate query + Python join — for reverse FK
                         .prefetch_related(
                             Prefetch(
                                 'line_items__product',
                                 queryset=Product.objects.only('id', 'name', 'sku'),
                             )
                         )
        )

Rule of thumb:

select_related: use for ForeignKey and OneToOne — does a SQL JOIN
prefetch_related: use for ManyToMany and reverse ForeignKey — does a separate WHERE id IN (...) query then joins in Python

Also add only() to avoid SELECT *:

Order.objects.only('id', 'total', 'status', 'created_at').select_related('customer')

Verify the fix: With django-debug-toolbar, 100 orders + customers + line items should be 3–4 queries total, not 200+. Also add assert_num_queries in tests:

def test_order_list_queries(self):
    with self.assertNumQueries(3):
        self.client.get('/api/orders/')

You

I need to add a non-nullable column status to a 50M-row orders table. If I just run the migration it'll lock the table for minutes. How do I do this without downtime?

Agent

Three-phase deploy pattern for adding non-nullable columns to large tables:

Phase 1: Add column as nullable with a default (deploy immediately)

# migrations/0042_add_status_nullable.py
class Migration(migrations.Migration):
    operations = [
        migrations.AddField(
            model_name='order',
            name='status',
            field=models.CharField(max_length=20, null=True, default=None),
        ),
    ]

PostgreSQL adds nullable columns with a default instantly (no row rewrite). This migration is safe to run with traffic.

Phase 2: Backfill existing rows in batches (run as management command)

# management/commands/backfill_order_status.py
Order.objects.filter(status__isnull=True).update(status='pending')
# For 50M rows, do this in chunks:
for batch_ids in chunked_queryset(Order.objects.filter(status__isnull=True).values_list('id', flat=True), 10000):
    Order.objects.filter(id__in=batch_ids).update(status='pending')
    time.sleep(0.1)  # brief pause to avoid replication lag

Phase 3: Add NOT NULL constraint once all rows are populated

# migrations/0043_order_status_not_null.py
operations = [
    migrations.AlterField(
        model_name='order',
        name='status',
        field=models.CharField(max_length=20, null=False, default='pending'),
    ),
]

In PostgreSQL 12+, adding NOT NULL to a column that has no NULLs uses a metadata-only change — no table scan if you set a CHECK (status IS NOT NULL) constraint in a previous transaction.

Deploy order: Phase 1 migration → backfill command → Phase 3 migration.

Get Started

How to install and use this skill in your preferred environment.

Skills are designed for AI coding agents (Claude Code, Cursor, Windsurf) and IDE-based workflows where the agent can read files, run scripts, and act on your codebase.

Models & Context

Which AI models and context windows work best with this skill.

Recommended Models

Claude Sonnet 4 or GPT-4o handle Django ORM patterns and DRF serializers well. Verify async Django view compatibility with your Django version (async views require 3.1+).

Context Window

SKILL.md ~5KB. Large model and serializer refactors benefit from 64K+ context.

Pro tips for best results

1

Be specific

Include numbers — users, budget, RPS — so the skill can size the architecture.

2

Share constraints

Compliance needs, team size, and existing stack all improve the output.

3

Iterate

Start with a high-level design, then ask follow-ups for IaC, cost analysis, or security review.

4

Combine skills

Pair with companion skills below for end-to-end coverage.

Works Great With

These skills complement Django Developer for end-to-end coverage. Install them together for better results.

Python Pro

Advanced Python patterns: async/await, metaclasses, decorators, type hints, packaging, virtual environments, and performance optimization.

PythonAsync

Senior Backend

REST APIs, database optimization, authentication, and microservices.

BackendAPIs

Database Designer

Schema analysis, ERD generation, index optimization, and migrations.

DatabaseSchema

TDD Guide

Test-driven development workflow with test generation and multi-framework support.

TDDTesting

Performance Profiler

Node/Python/Go profiling, bundle analysis, and load testing.

PerformanceProfiling

$ skillfish add johnefemer/skillfish --all # install all skills at once

Ready to try Django Developer?

Install the skill and start getting expert-level guidance in your workflow — any agent, any IDE.