viewflow/seedkit / skills/django-seedkit
django-seedkit
FlaggedBootstrap a new Django project, or add components — auth (allauth, magic-link, axes, 2FA), payments (Stripe, dj-stripe), REST (django-modern-rest, django-bolt), Celery / Django Tasks, async views & WebSockets (ASGI, uvicorn worker, django-channels, channels-redis), Tailwind+DaisyUI, favicon, SEO meta tags + sitemap, HTML email templates, S3 storage, structlog, healthchecks, Docker, CI, deploy (VPS / Fly / GitHub-SSH), dbbackup, Sentry/Bugsink — to an existing Django codebase. Use whenever the user wants to scaffold Django, integrate a Django package, set up async / WebSockets, set up production deploys, wire CI/CD, or extend an existing Django project.
references/custom-user.md
View on GitHub# Custom User Model
Docs: <https://docs.djangoproject.com/en/6.1/topics/auth/customizing/#substituting-a-custom-user-model>
Set `AUTH_USER_MODEL` **before the first `migrate`**. Adding it later requires data migrations and breaks foreign keys to `auth.User`.
An empty subclass suffices — extending it later (extra fields, email-as-username) doesn't require schema changes to existing rows.
## Create the app
```sh
uv run django-admin startapp users
```
For a nested layout: `mkdir -p apps/users && uv run django-admin startapp users apps/users` and adjust the dotted reference.
## users/models.py
Username-based login — plain `AbstractUser`:
```python
from django.contrib.auth.models import AbstractUser
class User(AbstractUser):
pass
```
Email-only login (allauth with `ACCOUNT_LOGIN_METHODS = {"email"}`, or `django-mail-auth`) — drop `username`, make `email` unique, switch `USERNAME_FIELD`, and ship a manager that creates users by email:
```python
from typing import TYPE_CHECKING
from django.contrib.auth.models import AbstractUser, BaseUserManager
from django.db import models
from django.db.models.functions import Lower
if TYPE_CHECKING:
from typing import ClassVar
class UserManager(BaseUserManager["User"]):
use_in_migrations = True
def _create_user(self, email: str, password: str | None, **extra_fields):
if not email:
raise ValueError("Email is required")
email = self.normalize_email(email).lower() # Foo@x and foo@x are the same account
user = self.model(email=email, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, email: str, password: str | None = None, **extra_fields):
extra_fields.setdefault("is_staff", False)
extra_fields.setdefault("is_superuser", False)
return self._create_user(email, password, **extra_fields)
def create_superuser(self, email: str, password: str | None = None, **extra_fields):
extra_fields.setdefault("is_staff", True)
extra_fields.setdefault("is_superuser", True)
if extra_fields.get("is_staff") is not True:
raise ValueError("Superuser must have is_staff=True.")
if extra_fields.get("is_superuser") is not True:
raise ValueError("Superuser must have is_superuser=True.")
return self._create_user(email, password, **extra_fields)
class User(AbstractUser):
username = None # type: ignore[assignment]
email = models.EmailField(unique=True)
USERNAME_FIELD = "email"
REQUIRED_FIELDS: "ClassVar[list[str]]" = []
objects: "ClassVar[UserManager]" = UserManager()
class Meta:
constraints = [
# DB-level backstop for paths that bypass the manager (admin, shell).
models.UniqueConstraint(Lower("email"), name="user_email_ci_unique"),
]
```
## users/admin.py
Plain variant — default `UserAdmin` works:
```python
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import User
admin.site.register(User, UserAdmin)
```
Email-only variant — override add/change forms; default `UserCreationForm` expects a `username` field that no longer exists:
```python
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.forms import (
ReadOnlyPasswordHashField,
UserChangeForm,
UserCreationForm,
)
from .models import User
class UserCreationFormEmail(UserCreationForm):
class Meta(UserCreationForm.Meta):
model = User
fields = ("email",)
class UserChangeFormEmail(UserChangeForm):
class Meta(UserChangeForm.Meta):
model = User
# Parent pins {"username": UsernameField, "password": ReadOnlyPasswordHashField}.
# Drop username (the model has no such field) but KEEP the password mapping.
# ReadOnlyPasswordHashField is what shows the hash + "change password" link
# in admin. Without it the password field is editable plain text and saving
# the user form silently overwrites user.password with whatever was typed,
# breaking login.
field_classes = {"password": ReadOnlyPasswordHashField}
@admin.register(User)
class UserAdmin(BaseUserAdmin):
add_form = UserCreationFormEmail
form = UserChangeFormEmail
list_display = ("email", "is_staff", "is_superuser")
ordering = ("email",)
search_fields = ("email",)
readonly_fields = ("last_login", "date_joined")
fieldsets = (
(None, {"fields": ("email", "password")}),
("Permissions", {"fields": ("is_active", "is_staff", "is_superuser", "groups", "user_permissions")}),
("Important dates", {"fields": ("last_login", "date_joined")}),
)
add_fieldsets = (
(None, {"classes": ("wide",), "fields": ("email", "password1", "password2", "is_active", "is_staff", "is_superuser")}),
)
```
`add_fieldsets` includes the permission flags so admin can create a superuser in one round-trip; without them, every new user starts as a regular user and a second edit pass is needed to grant `is_staff` / `is_superuser`.
## Settings
```python
INSTALLED_APPS = [
...
"users",
]
AUTH_USER_MODEL = "users.User"
```
## Migrate
`startapp` does not generate a migration for the new `User` model. Run
`makemigrations users` immediately, then `migrate`:
```sh
uv run manage.py makemigrations users
uv run manage.py migrate
uv run manage.py createsuperuser
```
Without the explicit `makemigrations`, the next `migrate` fails with
`Dependency on app with no migrations: users`. The `users_user` table
replaces `auth_user`.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |