Qwen3.5-397B Autonomous Code Generation: From Dental Clinic Sites to Django CMS Foundations
Two code generation validations using the 400B-class MoE model Qwen3.5-397B. One-shot generation of a 6-page dental clinic static site (HTML+Tailwind+Alpine.js) and single-turn generation of a WordPress-like Django CMS foundation (8 apps, 20+ models). Practical data from the era where humans write specs and AI builds the implementation.
Summary
Qwen3.5-397B brings “hand over the spec, get back the code” closer to reality. This article records two validations:
- Dental clinic static site — 6 pages in HTML + Tailwind CSS + Alpine.js, one-shot generation (~18 minutes)
- WordPress-like Django CMS foundation — 8 apps, 20+ models, complete Django configuration in a single turn
Both follow the pattern of “human writes the SPEC, AI implements the code.” Post-generation manual corrections were relatively few. The massive 397B parameter space makes it easier to maintain cross-file dependency relationships.
Prerequisites
Execution Environment
- GPU: NVIDIA RTX PRO 6000 Blackwell Max-Q (96GB VRAM)
- CPU: AMD EPYC 9175F (16C/32T, 512MB L3)
- Runtime: Podman container based on ik_llama-cuda
- Quantization: IQ4_KSS
- Key arguments:
--cpu-moe,--no-mmap,-fa on,-c 262144
Operational Constraints
397B inference on EPYC + 1GPU drops decode speed to single-digit tok/s. Somewhat less suitable for interactive use. This model is operated exclusively for “single-turn structural generation” and “nightly batch code generation.”
Validation 1: Dental Clinic Static Site (One-Shot Generation)
Requirements
- Structure: 6 pages — index, services, doctors, info, visit, access
- Tech constraints: No build step, Tailwind CSS (CDN), Alpine.js (CDN), no external UI libraries
- Required features: Mobile hamburger menu (ESC/focus management), category filtering, FAQ accordion, estimate modal, form validation
- Quality: Semantic HTML5, ARIA attributes, keyboard navigation, responsive design
Results
The LLM completed the entire process in approximately 18 minutes:
- Directory scaffolding (
/site+/assets) - HTML generation (page-specific content with consistent shared header/footer)
- Accessibility integration (semantic HTML5, focus management, ESC key support)
- README.md creation (local setup instructions and known limitations)
Generated Page Breakdown
| Page | Key Content |
|---|---|
| index.html | Hero, 8 service cards, 6 “Why Choose Us” points, 4 doctor previews, news, hours |
| services.html | 16 treatment cards + Alpine.js category filter (4 categories) + 6-item FAQ accordion |
| doctors.html | 6 doctor profiles + expandable details (specialties, languages, certifications) |
| info.html | Fee table (8 treatments) + modal cost estimates, insurance/payment methods |
| visit.html | 6-step timeline, reservation methods, form with validation states |
| access.html | Contact/hours, map placeholder, direction tabs (car/train/walk) |
Assessment
- Code quality: Clean markup, consistent Tailwind utilities, responsive and accessibility requirements met at a high level
- Efficiency: Coherent 6-page site generated one-shot from a complex prompt
- Practicality: No build step means immediate browser preview and deployment. Highly useful for rapid prototyping
Validation 2: Django CMS Foundation (Single-Turn Generation)
Requirements
Input was a detailed technical specification (SPEC) for rebuilding WordPress core concepts in Django:
- Posts / Pages (publish status, scheduled posts, password protection)
- Categories / Tags (unified hierarchical + flat classification)
- Comments, Media Library, Menus / Navigation
- Drafts, scheduled publishing, visibility control
- Revision history
- PostgreSQL-friendly design (JSONField, indexing, full-text search ready)
Generated System Structure
The AI enforced strict Separation of Concerns based on Django best practices, not just a flat list of models.
Common Abstract Models (apps/core/models.py):
Abstract base classes like TimeStampedModel, SoftDeleteModel, PublishableModel — DRY principle enforced at the physical code level.
8-App Architecture:
| App | Responsibility |
|---|---|
| accounts | User and role management |
| core | Site settings, multi-site extensibility point |
| content | Core for posts, pages, and revisions |
| taxonomy | Category (hierarchical) + Tag (flat) classification |
| media | Media library (SHA256 deduplication, Alt/Caption management) |
| comments | Comment functionality |
| navigation | Menu and navigation management |
| seo | SEO metadata management |
WP Concept → Django Implementation Mapping
| WP Concept | Django Implementation | Implemented Features |
|---|---|---|
| Post / Page | content.Post / Page | Publish status, scheduled posts, password protection |
| Taxonomy | taxonomy.Term | Unified category (hierarchical) and tag (flat) |
| Post Meta | content.PostMeta | Dynamic expansion via PostgreSQL JSONField |
| Revision | content.Revision | Snapshot storage and rollback |
| Media | media.MediaAsset | SHA256 deduplication, Alt/Caption management |
Assessment: Contextual Understanding Depth of Massive Models
Smaller 17B-class models frequently produce method name and argument mismatches when handling cross-file dependencies (e.g., OneToOne links between SEOEntry and Post).
Qwen3.5-397B accurately reused properties defined in apps/core/models.py (such as is_public) within apps/content/models.py QuerySet definitions. python manage.py makemigrations completed with limited post-generation fixes.
Analysis: The Shift to “Prompt Architect”
Speed vs Quality Trade-off
The 397B model is slow. But the consistency of code produced in a single pass is high. Investing time in perfecting the SPEC and firing a single turn yields better total productivity than iterative conversational debugging.
Differentiation from Smaller Models
- 17B-class (Scout, etc.): Interactive coding assistance, refactoring, single-function generation
- 397B-class (Qwen3.5): Multi-file, multi-model structural generation, architecture-level code production
Operational Pattern
- Human writes the SPEC (requirements + architecture design)
- Single-turn submission to the 397B model
- Review and minor fixes on generated code
- Deploy
This “blueprint → AI implementation → human review” pipeline is the practical form of “on-premise intelligence” that loFT LLC pursues.
Reproduction Steps
Dental Clinic Site
- Start Qwen3.5-397B (or equivalent coding model)
- Submit the requirements from this article’s “Validation 1 Requirements” section as the prompt
- Open the 6 generated HTML files in a browser to verify
Django CMS Foundation
- Create a WordPress→Django mapping specification (concept definitions for Post/Page/Taxonomy/Media/Revision)
- Specify project structure, design principles, and non-scope items
- Submit to Qwen3.5-397B in a single turn
- Verify consistency with
python manage.py makemigrations - Fix any inconsistencies manually