CLAUDE.md Template: Angular Material + Django Celery Starter

Overview

A CLAUDE.md template is a copyable Claude Code instruction block designed to be pasted into a CLAUDE.md file to drive a project stack. This page provides a complete, ready-to-paste CLAUDE.md for the Angular Material + Django Celery stack, including architecture guidance, file structure, authentication, and production rules. Direct answer: paste the block below into CLAUDE.md to bootstrap a reproducible setup for this stack.

When to Use This CLAUDE.md Template

• You are starting a new Angular Material frontend paired with a Django REST backend and Celery tasks.
• You need a copyable CLAUDE.md block to document roles, rules, and constraints for Claude Code in this stack.
• You require stack-specific constraints to avoid architecture drift during development and deployment.
• You want a ready-made project structure, validation, and security rules to share with teammates or a CI workflow.

Copyable CLAUDE.md Template

# CLAUDE.md

Project role: Full-stack Lead Engineer for Angular Material + Django Celery

Architecture rules:
- Frontend: Angular (v16+) with Angular Material components and a clean component-per-feature structure.
- Backend: Django 4.x + DRF with serializers and viewsets; Celery for async tasks using Redis as broker/backend.
- API layer: JWT-based authentication (DRF SimpleJWT) with refresh tokens; API versioning v1.
- Communication: RESTful API with predictable schemas; frontend communicates via HTTP with proper CORS/configs.
- Deployment: Dockerized frontend and backend; shared environment variables via .env files; consistent runtime versions.

File structure rules:
- frontend/ contains angular.json, package.json, tsconfig.*.json, src/ with app/ and assets/
- backend/ contains manage.py, django_project/ with settings.py, urls.py, wsgi.py, app/ with models.py, serializers.py, views.py, urls.py, and celery.py
- Dockerfile(s) for frontend and backend; docker-compose.yml for local dev

Authentication rules:
- DRF JWT (SimpleJWT): access token short-lived, refresh token long-lived; rotation and revocation where applicable
- CSRF is enforced for cookie-based sessions; API endpoints use token-based auth where possible
- Protect sensitive endpoints with proper permissions and throttling

Database rules:
- PostgreSQL with proper migrations; use environment-based connection settings
- Use atomic transactions for write-heavy API endpoints

Validation rules:
- Server-side validation using DRF serializers; client-side validation with Angular forms
- Sanitize all inputs; reject unexpected fields early

Security rules:
- Use HTTPS in all environments; secure cookies; CSRF protection enabled
- Restrict CORS to allowed origins; avoid wildcard origins in prod
- Do not hard-code secrets; use environment variables and secret managers
- Keep Celery worker processes isolated behind proper network rules

Testing rules:
- Backend: unit tests for models, serializers, viewsets; integration tests for API endpoints; Celery task tests
- Frontend: unit tests for components/services; end-to-end tests for critical flows using Cypress or similar
- Run tests in CI with a matrix for frontend/backend; ensure tests pass before merges

Deployment rules:
- Use docker-compose for local development; Kubernetes or cloud container services for prod
- Migrate DB automatically on deployment; seed essential data via migrations/fixtures
- Collect logs and metrics; monitor Celery task queues and API latency

Things Claude must not do:
- Do not bypass authentication checks or expose protected endpoints
- Do not call external services with untrusted input or without credentials
- Do not hard-code credentials or secrets in code or CLAUDE.md
- Do not bypass CORS/CSRF protections in production configs

Recommended Project Structure

angular-material-django-celery/
├── frontend/
│   ├── src/
│   │   ├── app/
│   │   │   └── components/
│   │   └── main.ts
│   ├── angular.json
│   ├── package.json
│   └── tsconfig.json
├── backend/
│   ├── manage.py
│   ├── django_project/
│   │   ├── settings.py
│   │   ├── urls.py
│   │   └── wsgi.py
│   ├── app/
│   │   ├── models.py
│   │   ├── serializers.py
│   │   ├── views.py
│   │   └── urls.py
│   ├── celery.py
│   ├── requirements.txt
│   └── CeleryWorker/
│       └── __init__.py
├── docker-compose.yml
└── README.md

Core Engineering Principles

• Clear separation of concerns between frontend and backend with well-defined interfaces (APIs and components).
• Explicit architecture constraints to prevent drift and ensure reproducibility.
• Principle of least privilege for services, tokens, and network access.
• Type-safe contracts on API boundaries; emphasize validation and predictable schemas.
• Automated tests and CI checks; deterministic deployment processes.

Code Construction Rules

• Frontend must use Angular Material components for all UI widgets; avoid custom CSS that conflicts with Material themes.
• Backend must expose DRF viewsets with serializers; use PostgreSQL migrations for schema changes.
• Celery tasks must be idempotent and include retry/backoff strategies; use Redis as broker/backend.
• Environment configuration must be driven by environment variables; avoid hard-coded values.
• Authentication should rely on JWTs; protect endpoints with DRF permissions and throttling.
• All API inputs must be validated on the server; client-side validation mirrors server rules.

Security and Production Rules

• Serve over HTTPS; enforce HSTS; use secure cookies for tokens.
• Restrict CORS to known frontends; disable wildcards in production.
• Regularly rotate secrets; use secret management; avoid logging sensitive data.
• Keep dependencies up to date and audit for vulnerabilities; pin versions where possible.
• Configure Celery with proper queues, timeouts, and monitor task failures.

Testing Checklist

• Backend: unit tests for models/serializers; integration tests for API endpoints; Celery task testing with in-memory broker if possible.
• Frontend: unit tests for components and services; UI tests for key flows; accessibility checks.
• CI/CD: run full test suite on PRs; linting and type checks; ensure container builds succeed.

Common Mistakes to Avoid

• Mixing frontend logic into backend services; keep concerns separated.
• Using non-deterministic tests that rely on external services without mocks.
• Over-permissive API permissions or insecure token handling.
• Skipping migrations or seeding data in production deployment steps.

Related implementation resources: AI Use Case for Software Agencies Using Github Copilot To Accelerate Boilerplate Code Generation for New Client Mvps and Skill files and CLAUDE.md templates to enforce frontend design consistency in production AI workflows.

FAQ

Below are concise answers to common questions about this CLAUDE.md Template for Angular Material + Django Celery.