
django-skills
Skills for Django development: fix type errors, upgrade JavaScript and Python dependencies
- GitHub stars
- 32
Install
/plugin install django-skills@django-skillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add saaspegasus/django-skills.
Contents
Discovered from sourceSkills 3
Your task
To fix types, do the following.
- First run the type checker to see what the issues are:
uv run mypy . - Group the errors you find in to logical buckets.
- For each bucket of errors, go through the errors one at a time, tell me the fix you want to apply, and then ask if I have any questions or suggestions before proceeding.
- Only once I approve, apply the fix and move onto the next error in the bucket.
- Once you've completed a bucket, ask me if I'd like to move on to the next bucket.
Prefer cast() over type: ignore
When mypy can't infer the correct type, prefer using cast() over # type: ignore:
# Preferred - documents the expected type
choices = cast(list[tuple[str, str]], field.choices)
# Avoid when cast is possible - just silences the error
choices = list(field.choices) # type: ignore[arg-type]
Why: cast() explicitly documents what type you expect, making the code more readable and maintainable. It also doesn't silence other potential errors on the same line.
Prefer proper errors over assertions for null checks
When adding null checks to satisfy mypy, prefer raising proper exceptions over using assert:
# Preferred - proper error handling
if obj.related_field is None:
raise ValueError("Object must have a related field")
result = obj.related_field.some_method()
# Avoid - assertions can be disabled with -O flag
assert obj.related_field is not None
result = obj.related_field.some_method()
Why: Assertions can be disabled in production with python -O, making them unreliable for runtime validation. Proper exceptions ensure the check always runs and provides better error handling.
When using type: ignore, add a comment
If type: ignore is necessary (e.g., mypy limitation with valid code), always add a short explanation:
# Good - explains why the ignore is needed
self.tier = tier # type: ignore[misc] # mypy can't handle Enum tuple values with custom __init__
# Bad - no explanation
self.tier = tier # type: ignore[misc]
Type Hints for Django Lazy Translation Strings
When using type hints with Django's lazy translation strings (gettext_lazy), use the following pattern to avoid mypy errors while keeping the code working in production (where django-stubs-ext is not installed):
from __future__ import annotations # Must be the first import
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from django_stubs_ext import StrOrPromise
# Then use StrOrPromise in type hints
def my_function(name: StrOrPromise) -> StrOrPromise: ...
class MyData:
title: StrOrPromise
description: StrOrPromise
Why this pattern:
from __future__ import annotationsmakes type annotations strings at runtime (not evaluated)if TYPE_CHECKING:ensures the import only happens during type checking, not at runtimedjango-stubs-extis a dev dependency and won't be available in production- This pattern allows both regular strings and lazy translation strings to be accepted
Your task
Upgrade all JavaScript dependencies and verify nothing is broken.
Step 1: Check for available upgrades
Run npx npm-check-updates to see what upgrades are available. Review the output and
present the list to the user.
Step 2: Update package.json
Run npx npm-check-updates -u to update package.json with the new versions.
Step 3: Install updated dependencies
Run make npm-install to install the upgraded dependencies and update package-lock.json.
Step 4: Run post-upgrade checks
Run these checks sequentially, stopping if any step fails:
- TypeScript type checking: Run
make npm-type-checkand report any new type errors. - Build: Run
make npm-buildto verify the production build still works. - Tests: Run
make testto verify the test suite still passes.
Step 5: Summarize and commit
Summarize what was done:
- Which packages were upgraded (notable version changes)
- Whether any type errors were introduced
- Whether the build succeeded
- Whether all tests passed
- Any issues that need manual attention
If there were failures, present the issues and ask how the user wants to proceed.
If everything passed, ask the user if they'd like to commit the changes, and commit them if so.
Your task
Upgrade all Python dependencies and verify nothing is broken.
Step 1: Upgrade the lock file
Run uv lock --upgrade --exclude-newer "7 days" to upgrade all dependencies to their latest compatible
versions (with a 7-day cooldown to mitigate supply-chain attacks).
Review the output for any resolution errors. If there are conflicts, report them to the user and ask how to proceed before continuing.
Step 2: Remove the cooldown marker from the lock file
uv records the --exclude-newer cutoff inside uv.lock as project configuration. Since it
isn't declared in pyproject.toml, any later uv sync or uv run sees a config mismatch,
discards the lockfile, and silently re-resolves everything to the newest versions — undoing
the cooldown. Prevent this by deleting the [options] block at the top of uv.lock
(the exclude-newer / exclude-newer-span lines) before syncing:
sed -i '/^\[options\]$/,/^$/d' uv.lock
The cooldown-resolved versions stay in place; only the marker is removed. Verify with
grep exclude-newer uv.lock (should print nothing).
Step 3: Sync the environment
Run uv sync to install the upgraded dependencies into the virtual environment.
Step 4: Run post-upgrade checks
Run these checks sequentially, stopping if any step fails:
- Type checking: Run
uv run mypy .and report any new type errors. These may be caused by updated type stubs or changes in library APIs. - Tests: Run
make testto verify the test suite still passes.
Step 5: Summarize and commit
Summarize what was done:
- Which packages were upgraded (notable version changes)
- Whether any type errors were introduced
- Whether all tests passed
- Any issues that need manual attention
If there were failures, present the issues and ask how the user wants to proceed.
If everything passed, ask the user if they'd like to commit the changes, and commit them if so.
Sponsors
Details
- Marketplace
- saaspegasus/django-skills
- Category
- Community