@oriro/orirocli 0.1.0

package/skills/craft/idea-to-deploy/references/gcp-deployment.md

@@ -0,0 +1,268 @@
+# GCP Deployment Playbook
+
+This file covers the full provisioning and deployment sequence on Google Cloud Platform.
+
+---
+
+## GCP Services Used
+
+| Service           | Purpose                                                |
+| ----------------- | ------------------------------------------------------ |
+| Cloud Run         | Host backend API / Next.js app (serverless containers) |
+| Cloud SQL         | Managed PostgreSQL database                            |
+| Artifact Registry | Store Docker images                                    |
+| Secret Manager    | Store all secrets / env vars                           |
+| Firebase Hosting  | Host static frontends (if separate from Next.js)       |
+| Cloud Storage     | Static assets, file uploads                            |
+| Cloud Build       | CI/CD (optional, recommended for handoff)              |
+| Memorystore       | Redis for caching / sessions (if needed)               |
+| IAM               | Service accounts and least-privilege roles             |
+
+---
+
+## Prerequisites (verify before provisioning)
+
+```bash
+# Check gcloud is installed
+gcloud --version
+
+# Check Docker is installed
+docker --version
+
+# Authenticate
+gcloud auth login
+gcloud auth configure-docker [REGION]-docker.pkg.dev
+```
+
+If `gcloud` is not installed, print the install link: https://cloud.google.com/sdk/docs/install
+and wait for user to confirm installation before continuing.
+
+---
+
+## Phase 6 — Full Provisioning Sequence
+
+### 6.1 — Project Setup
+
+```bash
+# Set project
+gcloud config set project $GCP_PROJECT_ID
+gcloud config set compute/region $GCP_REGION
+
+# Enable all required APIs in one command
+gcloud services enable \
+  run.googleapis.com \
+  sqladmin.googleapis.com \
+  secretmanager.googleapis.com \
+  artifactregistry.googleapis.com \
+  cloudbuild.googleapis.com \
+  storage.googleapis.com
+```
+
+### 6.2 — Artifact Registry
+
+```bash
+gcloud artifacts repositories create $APP_NAME \
+  --repository-format=docker \
+  --location=$GCP_REGION \
+  --description="Docker images for $APP_NAME"
+```
+
+### 6.3 — Cloud SQL (PostgreSQL)
+
+```bash
+# Create instance (db-f1-micro for dev/small apps, db-g1-small for production)
+gcloud sql instances create $APP_NAME-db \
+  --database-version=POSTGRES_16 \
+  --tier=db-g1-small \
+  --region=$GCP_REGION \
+  --storage-auto-increase \
+  --backup-start-time=02:00
+
+# Create database
+gcloud sql databases create $APP_NAME --instance=$APP_NAME-db
+
+# Set root password
+gcloud sql users set-password postgres \
+  --instance=$APP_NAME-db \
+  --password=$DATABASE_PASSWORD
+```
+
+Connection string format:
+
+```
+postgresql://postgres:$DATABASE_PASSWORD@/$APP_NAME?host=/cloudsql/$GCP_PROJECT_ID:$GCP_REGION:$APP_NAME-db
+```
+
+### 6.4 — Secret Manager
+
+Store every secret from `.env`:
+
+```bash
+# Example — repeat for each secret
+echo -n "$DATABASE_URL" | \
+  gcloud secrets create DATABASE_URL --data-file=- --replication-policy=automatic
+
+echo -n "$NEXTAUTH_SECRET" | \
+  gcloud secrets create NEXTAUTH_SECRET --data-file=- --replication-policy=automatic
+
+# Add all other secrets similarly
+```
+
+### 6.5 — IAM Service Account
+
+```bash
+# Create service account
+gcloud iam service-accounts create $APP_NAME-sa \
+  --display-name="$APP_NAME Service Account"
+
+SA_EMAIL="$APP_NAME-sa@$GCP_PROJECT_ID.iam.gserviceaccount.com"
+
+# Grant roles
+gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
+  --member="serviceAccount:$SA_EMAIL" \
+  --role="roles/cloudsql.client"
+
+gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
+  --member="serviceAccount:$SA_EMAIL" \
+  --role="roles/secretmanager.secretAccessor"
+
+gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
+  --member="serviceAccount:$SA_EMAIL" \
+  --role="roles/storage.objectAdmin"
+```
+
+---
+
+## Phase 7 — Deployment Sequence
+
+### 7.1 — Build & Push Docker Image
+
+```bash
+IMAGE="$GCP_REGION-docker.pkg.dev/$GCP_PROJECT_ID/$APP_NAME/backend:latest"
+
+docker build -t $IMAGE ./backend
+docker push $IMAGE
+```
+
+### 7.2 — Run DB Migrations
+
+```bash
+# Via Cloud Run Job (one-time migration runner)
+gcloud run jobs create migrate-$APP_NAME \
+  --image=$IMAGE \
+  --command="npx","prisma","migrate","deploy" \
+  --set-secrets="DATABASE_URL=DATABASE_URL:latest" \
+  --add-cloudsql-instances=$GCP_PROJECT_ID:$GCP_REGION:$APP_NAME-db \
+  --region=$GCP_REGION
+
+gcloud run jobs execute migrate-$APP_NAME --region=$GCP_REGION --wait
+```
+
+### 7.3 — Deploy Backend to Cloud Run
+
+```bash
+gcloud run deploy $APP_NAME-backend \
+  --image=$IMAGE \
+  --region=$GCP_REGION \
+  --platform=managed \
+  --allow-unauthenticated \
+  --service-account=$SA_EMAIL \
+  --add-cloudsql-instances=$GCP_PROJECT_ID:$GCP_REGION:$APP_NAME-db \
+  --set-secrets="DATABASE_URL=DATABASE_URL:latest,NEXTAUTH_SECRET=NEXTAUTH_SECRET:latest" \
+  --min-instances=0 \
+  --max-instances=10 \
+  --memory=512Mi \
+  --cpu=1
+```
+
+### 7.4 — Deploy Frontend
+
+**If Next.js (fullstack on one service):** Same as backend deploy — Next.js handles both.
+
+**If separate static frontend (React/Vite/Astro):**
+
+```bash
+# Build
+cd frontend && npm run build
+
+# Deploy to Firebase Hosting
+npm install -g firebase-tools
+firebase login --no-localhost
+firebase init hosting  # select existing project
+firebase deploy --only hosting
+```
+
+Or deploy to Cloud Storage + CDN:
+
+```bash
+gsutil mb gs://$APP_NAME-frontend
+gsutil web set -m index.html -e 404.html gs://$APP_NAME-frontend
+gsutil -m cp -r dist/* gs://$APP_NAME-frontend
+gsutil iam ch allUsers:objectViewer gs://$APP_NAME-frontend
+```
+
+---
+
+## App-Type Deployment Variants
+
+### Full-stack Next.js (most common)
+
+- Single Docker image, single Cloud Run service
+- Next.js handles frontend SSR + API routes
+- Connect Cloud SQL via Unix socket
+
+### Separate Frontend + Backend
+
+- Two Cloud Run services (or Firebase Hosting + Cloud Run)
+- Set `NEXT_PUBLIC_API_URL` / `VITE_API_URL` to backend Cloud Run URL at build time
+- Enable CORS on backend for frontend domain
+
+### API-only backend
+
+- Single Cloud Run service
+- No frontend deployment needed
+- Document API with auto-generated OpenAPI/Swagger
+
+### E-commerce
+
+- Same as full-stack Next.js
+- Add Stripe webhook endpoint: `POST /api/webhooks/stripe`
+- Store `STRIPE_SECRET_KEY` and `STRIPE_WEBHOOK_SECRET` in Secret Manager
+
+---
+
+## Post-Deploy Checklist
+
+- [ ] App loads at Cloud Run URL
+- [ ] Auth flows work (login, OAuth callback, logout)
+- [ ] DB migrations ran successfully
+- [ ] All secrets accessible (no missing env var errors)
+- [ ] HTTPS working (automatic on Cloud Run)
+- [ ] Health check endpoint responds: `GET /api/health`
+
+---
+
+## Custom Domain (post-handoff step — mention in handoff)
+
+```bash
+gcloud beta run domain-mappings create \
+  --service=$APP_NAME-backend \
+  --domain=yourdomain.com \
+  --region=$GCP_REGION
+```
+
+Then add the DNS records shown in the output to your domain registrar.
+
+---
+
+## Cost Estimates (for user awareness)
+
+| Service                 | Estimated monthly cost |
+| ----------------------- | ---------------------- |
+| Cloud Run (low traffic) | $0–5 (scales to zero)  |
+| Cloud SQL db-g1-small   | ~$25/month             |
+| Artifact Registry       | ~$0.10/GB/month        |
+| Secret Manager          | ~$0.06/10k accesses    |
+| Firebase Hosting        | Free tier (10GB/month) |
+
+**Total for small app: ~$25–35/month.** Inform user at handoff.

package/skills/craft/idea-to-deploy/references/stack-selection.md

@@ -0,0 +1,117 @@
+# Stack Selection Guide
+
+The agent selects the best stack per project. Use this guide to make that decision.
+
+## Decision Tree
+
+### Step 1 — Identify App Type
+
+| Signal in idea                                             | App Type                |
+| ---------------------------------------------------------- | ----------------------- |
+| "landing page", "portfolio", "blog", "marketing site"      | Frontend-only           |
+| "API", "webhook", "microservice", "data pipeline"          | API/backend-only        |
+| "dashboard", "admin panel", "internal tool"                | Full-stack (data-heavy) |
+| "SaaS", "subscription", "multi-tenant", "client accounts"  | Full-stack SaaS         |
+| "shop", "store", "product catalog", "checkout", "payments" | E-commerce full-stack   |
+| "mobile app backend", "React Native", "Flutter"            | API-only backend        |
+
+### Step 2 — Pick Frontend
+
+| Situation                              | Choice                               | Reason                              |
+| -------------------------------------- | ------------------------------------ | ----------------------------------- |
+| SaaS / complex UI / real-time features | **Next.js** (React)                  | SSR, routing, API routes, ecosystem |
+| Simple marketing / static site         | **Astro** or **plain HTML+Tailwind** | Speed, no JS overhead               |
+| Admin dashboard                        | **Next.js** + shadcn/ui              | Component library fits perfectly    |
+| E-commerce                             | **Next.js**                          | SEO via SSR, Stripe integration     |
+| High interactivity / single-page app   | **React (Vite)**                     | Faster dev server, simpler setup    |
+
+### Step 3 — Pick Backend
+
+| Situation                         | Choice                                          | Reason                             |
+| --------------------------------- | ----------------------------------------------- | ---------------------------------- |
+| JavaScript/TypeScript frontend    | **Node.js + Express** or **Next.js API routes** | Unified language                   |
+| ML features, data processing      | **Python + FastAPI**                            | Ecosystem fit                      |
+| High-throughput API               | **Go + Gin**                                    | Performance                        |
+| Rapid prototype / CRUD heavy      | **Node.js + Fastify**                           | Fast to write                      |
+| Full Next.js app (simple backend) | **Next.js API routes**                          | No separate backend service needed |
+
+### Step 4 — Pick Database
+
+| Situation                      | Choice                     | Reason                    |
+| ------------------------------ | -------------------------- | ------------------------- |
+| Relational data, transactions  | **PostgreSQL** (Cloud SQL) | Gold standard, GCP native |
+| Document data, flexible schema | **Firestore**              | GCP native, serverless    |
+| Caching / sessions             | **Redis** (Memorystore)    | Speed                     |
+| Simple key-value               | **Firestore**              | Serverless, no management |
+| Analytics / time-series        | **BigQuery**               | GCP native, powerful      |
+
+Default to **PostgreSQL on Cloud SQL** unless the data is clearly document-oriented.
+
+### Step 5 — Pick ORM / Query Layer
+
+| Backend              | ORM                                     |
+| -------------------- | --------------------------------------- |
+| Node.js / TypeScript | **Prisma** (preferred) or Drizzle       |
+| Python               | **SQLAlchemy** + Alembic for migrations |
+| Go                   | **sqlc** or GORM                        |
+
+---
+
+## E-commerce Specifics
+
+Always include:
+
+- **Stripe** for payments (Stripe Checkout or Elements)
+- Product catalog, cart, orders data model
+- Webhook handler for Stripe events (`payment_intent.succeeded`, etc.)
+- Admin dashboard for order management
+
+Do NOT build a custom payment processor. Always use Stripe.
+
+---
+
+## SaaS Specifics
+
+Always include:
+
+- Multi-tenancy: each client (tenant) has isolated data (row-level via `tenant_id` FK)
+- Subscription billing via **Stripe Billing** (plans, usage, invoices)
+- Tenant onboarding flow (invite by email or self-serve signup)
+- Admin superuser panel separate from tenant-facing UI
+- API key management if the SaaS exposes an API to tenants
+
+---
+
+## Monorepo Structure (default)
+
+```
+/
+├── frontend/          # UI project
+├── backend/           # API / server
+├── shared/            # Shared types, utilities (TypeScript projects)
+├── infra/             # Deployment scripts / Terraform
+├── docker-compose.yml # Local dev
+├── .env.example       # All env vars, values blank
+└── README.md
+```
+
+Use **Turborepo** for JavaScript monorepos. Use a simple Makefile for Python/mixed monorepos.
+
+---
+
+## Current Best-Practice Defaults (update periodically)
+
+| Layer     | Current best choice                     | Notes                                              |
+| --------- | --------------------------------------- | -------------------------------------------------- |
+| Frontend  | Next.js 14+ (App Router)                | Use Server Components where possible               |
+| Styling   | Tailwind CSS + shadcn/ui                | Fastest to build polished UI                       |
+| Backend   | Node.js + Fastify or Next.js API routes | TypeScript throughout                              |
+| ORM       | Prisma                                  | Best DX, great GCP/PostgreSQL support              |
+| Auth      | NextAuth.js v5 (Auth.js)                | See auth-playbook.md                               |
+| Payments  | Stripe                                  | Industry standard                                  |
+| DB        | PostgreSQL 16 on Cloud SQL              | Reliable, GCP native                               |
+| Container | Docker + Cloud Run                      | Serverless, scales to zero                         |
+| IaC       | gcloud CLI scripts                      | Simple enough; Terraform for complex multi-service |
+
+The agent should stay current. If a clearly superior technology has emerged since this guide
+was written, use it and note the deviation in the blueprint.

package/skills/craft/image-generation-engineer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ORIRO.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/craft/image-generation-engineer/SKILL.md

@@ -0,0 +1,183 @@
+---
+watermark: ORIRO
+disable-model-invocation: true
+name: image-generation-engineer
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+description: >
+  World-class image-generation engineering — build, train, fine-tune, serve, and improve any
+  text-to-image / diffusion system. Activate for ANY task involving: diffusion models (DDPM,
+  DDIM, flow matching, rectified flow), architectures (U-Net, DiT, MM-DiT, latent diffusion),
+  FLUX.1 / FLUX.2 (schnell / dev / Kontext), Stable Diffusion / SDXL / SD3.5, Z-Image, VAE,
+  text conditioning (CLIP, OpenCLIP, T5-XXL), LoRA / DreamBooth / ControlNet fine-tuning,
+  samplers (DDIM, DPM-Solver++, LCM, adversarial distillation), classifier-free guidance,
+  FP8 / GGUF / INT8 quantization for image models, FID / CLIP-score evaluation, serving image
+  models (diffusers, vLLM, BentoML, Modal H100, Cloud Run), Nano Banana / gemini-2.5-flash-image,
+  or building ORIRO's own image engine. Use whenever the user wants to generate images, train or
+  fine-tune an image model, choose an image model, speed up image inference, evaluate image
+  quality, or deploy text-to-image — even if they never say "diffusion" or "FLUX". Last
+  researched: June 3 2026.
+metadata:
+  type: reference
+---
+
+# Image Generation Engineer
+
+How to build, train, serve, and improve any image-generation system — from the diffusion math up
+to production serving. This skill is the standing reference for every visual-generative task on
+<user>'s projects. Consult it before acting; load the relevant `references/` file for depth.
+
+The guiding principle: **don't reinvent what ships today.** Most tasks start by _using_ an existing
+open model (FLUX.1 [schnell], Apache 2.0) or the user's own API key (Nano Banana / Gemini), and only
+descend into custom architecture/training when there's a real reason. The decision tree below routes
+you; the reference files hold the depth.
+
+---
+
+## PART 0 — QUICK DECISION TREE (read this first, every time)
+
+```
+WHAT ARE YOU BUILDING?
+│
+├── Need images NOW, no training budget?
+│   → FLUX.1 [schnell] (Apache 2.0, 12B, 1-4 steps, commercial OK)
+│   → Serve via diffusers + vLLM or BentoML
+│
+├── Need to fine-tune an existing model?
+│   → LoRA on FLUX.1 [dev] (fastest, cheapest, best quality)
+│   → DreamBooth for concept injection
+│   → ControlNet adapter for structural conditioning
+│
+├── Building from scratch (research / custom architecture)?
+│   → Start: DDPM on small dataset (MNIST/CIFAR) — understand the math
+│   → Scale: Latent Diffusion (VAE + U-Net) on real images
+│   → Advance: DiT (replace U-Net with Transformer)
+│   → State of art: Flow Matching + MM-DiT (FLUX/SD3 architecture)
+│
+├── Need text conditioning?
+│   → CLIP text encoder (OpenCLIP ViT-L/14, Apache 2.0)
+│   → T5-XXL for nuanced language (SD3/FLUX use both CLIP+T5)
+│   → OpenCLIP BigG/14 for highest fidelity
+│
+├── Need inference speed?
+│   → DDIM sampler (50→10 steps, same quality)
+│   → LCM distillation (4-8 steps)
+│   → Latent adversarial distillation (1-4 steps, FLUX [schnell])
+│   → FP8 quantization (2× speed, half memory, negligible quality loss)
+│
+└── Need to serve at scale?
+    → vLLM 0.17.1 (continuous batching, FP8, multi-GPU)
+    → BentoML (unified API, auto-scaling)
+    → Modal H100 (per-request GPU, zero idle cost)
+```
+
+---
+
+## Reference map — where the depth lives
+
+Load the file that matches the task. Each is self-contained; don't read them all up front.
+
+| File                                  | Covers                                                                                                                                                                                     | Read when                                                                                                       |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
+| `references/foundations.md`           | Diffusion math: forward/reverse process, noise schedules, DDIM, flow matching / rectified flow, classifier-free guidance                                                                   | You're implementing the training objective, a sampler, or debugging why generations are noisy/blurry/off-prompt |
+| `references/architectures.md`         | U-Net, DiT, MM-DiT; VAE / latent space; CLIP & T5 text conditioning (single + dual encoder)                                                                                                | You're choosing or building a model backbone, a VAE, or a text-conditioning stack                               |
+| `references/training.md`              | Data pipeline, full training loop + config, LoRA fine-tuning, ControlNet                                                                                                                   | You're training or fine-tuning anything                                                                         |
+| `references/inference-and-serving.md` | Sampler comparison, quantization (FP8/GGUF/INT8), full inference pipeline, FID/CLIP eval, serving stacks (Modal, Cloud Run, vLLM, BentoML), open-model reference table, diffusers patterns | You're optimizing inference, evaluating quality, or deploying                                                   |
+
+For the deep math/architecture detail the decision tree references (e.g. the exact DDIM update, MM-DiT block, VAE loss), the canonical text lives in those files — pull it in rather than reconstructing from memory.
+
+---
+
+## ORIRO build plan — Use → Adapt → Build → Own
+
+ORIRO's image strategy is phased so we ship value immediately at $0 and only take on training cost
+when it pays for itself. Honor the OR-NO-TOKENS / zero-cost-to-ORIRO rule throughout: user BYOK and
+open Apache-2.0 models first, ORIRO-paid keys never.
+
+```
+Phase 1 — USE (ship NOW):
+  Nano Banana via the USER'S Google AI Studio API key. $0 to ORIRO, 500 free/day, immediate.
+  Model: gemini-2.5-flash-image. No training, no infra — just proxy the user's key.
+
+Phase 2 — ADAPT (months 3-6):
+  Fine-tune FLUX.1 [schnell] (Apache 2.0) on ORIRO style via LoRA on Modal H100 (~$50/run).
+  Custom styles: ORIRO aesthetic, UI mockups, avatars. Serve on Modal, $0.001-0.003/image.
+
+Phase 3 — BUILD (months 6-12):
+  Train a small DiT (~500M params) on a curated dataset. Specialize: UI/UX mockups, product
+  design, avatars. ORIRO-specific fine-tune on ORIRO user outputs (DPO flywheel). Host on
+  Cloud Run or Modal.
+
+Phase 4 — OWN (year 2+):
+  Full custom LDM or flow-matching model on ORIRO data + licensed public data. Independent of
+  any external provider. Image generation becomes a product line.
+```
+
+**Minimum viable engine (build now):** an `image` route where the user supplies their own Google AI
+Studio key and ORIRO proxies the request (never ORIRO's billing). Enhance prompts with a style map:
+
+```
+photorealistic → "photorealistic, 8K, professional photography"
+illustration   → "digital illustration, clean lines, vibrant colors"
+ui-mockup      → "clean UI mockup, Figma style, modern design system"
+icon           → "app icon, clean vector style, 1024×1024"
+game-asset     → "game asset, pixel art / 3D render, game-ready"
+enhanced_prompt = f"{prompt}, {STYLE_PROMPTS[style]}"
+```
+
+### Quality bar — do not ship below these
+
+For ANY ORIRO image engine, measure and gate on:
+
+- **FID ≤ 30** (acceptable for production; ≤10 excellent, matches real images)
+- **CLIP Score ≥ 0.28** (adequate text-image alignment)
+- **User rating ≥ 4.0/5.0** (in-app ratings)
+- **Generation speed ≤ 10s** (acceptable UX)
+- **Cost ≤ $0.01/image** (sustainable economics)
+
+Below these thresholds: do not ship to production.
+
+---
+
+## PART 10 — COMMON MISTAKES (and how to avoid them)
+
+These are the high-frequency failure modes. Most "my model is blurry / off-prompt / OOMing" reports
+trace back to one of these — check here before deep debugging.
+
+```
+MISTAKE 1: Training in pixel space for large images
+  FIX: Always use latent diffusion (VAE encoder first).  RULE: resolution > 128×128 → latent space.
+
+MISTAKE 2: Linear noise schedule for high resolution
+  FIX: cosine (standard) or sigmoid (best for 512+) schedule for 256+ px.
+
+MISTAKE 3: Only MSE loss for the VAE
+  FIX: add perceptual (LPIPS) + adversarial loss.  Pure MSE → blurry; perceptual → sharp edges.
+
+MISTAKE 4: Forgetting CFG during inference
+  FIX: guidance_scale 5-15 for text-to-image.  EXCEPTION: flow-matching models (FLUX [schnell]) = 0.
+
+MISTAKE 5: Attention-only LoRA targets
+  FIX: include FFN modules. q,k,v,o + gate_proj/up_proj/down_proj (or ff.net.*) = complete.
+
+MISTAKE 6: Not normalizing images to [-1, 1]
+  FIX: T.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5]).  Models expect [-1,1], not [0,1].
+
+MISTAKE 7: FP32 for training large models
+  FIX: BF16 mixed precision — bfloat16 is more stable than fp16 (which overflows) and 2× faster.
+
+MISTAKE 8: No EMA during training
+  FIX: keep an exponential moving average of weights (decay 0.9999). EMA weights = better at inference.
+
+MISTAKE 9: Fixed-resolution dataset
+  FIX: multi-aspect-ratio bucketing (SDXL technique). Bucket by AR → no padding → ~20% faster training.
+
+MISTAKE 10: Evaluating only on the training distribution
+  FIX: hold-out test set + out-of-distribution prompts. FID on held-out + CLIP score on diverse prompts.
+```
+
+---
+
+_Researched June 3 2026. Sources: arxiv (DDPM/DDIM/DiT/FLUX papers), HuggingFace Diffusers docs,
+Black Forest Labs FLUX repo, ICLR 2026 architecture-evolution blogpost, BentoML model guide, OpenCLIP
+GitHub. Update this skill whenever a new SOTA architecture ships._