luminary19
- 39 skills
- 0 followers
- 6 hours ago last updated
- ▌ Forge · luminary19 bundleForge suite — the entry point, router & orchestrator for headless 3D production on native Windows 11. START HERE when you need to create, render, rig, animate, simulate, or export any 3D asset — including polygon mesh modeling, parametric CAD, procedural geometry, PBR look-dev, UV unwrapping, baked textures, skeletal rigs, cloth/fluid sims, and web-delivery GLB export. With no argument it probes the project, picks the pipeline the situation needs, and RUNS it end-to-end by invoking each forge-* skill explicitly with the Skill tool — never narrating, always executing. `/forge <verb> [target]` dispatches to a specific forge-* skill or agent; `/forge init` writes the project's FORGE.md memory; `/forge help` shows the full stage menu. Use when the user says "use Forge", "model this in Blender", "render this headlessly", "rig this mesh", "export a GLB for the web", "generate a parametric shape", "bake textures", "UV unwrap", "run a sim", "set up Forge", or invokes /forge directly. Also use when atelier-webgl needs
- ▌ Atelier · luminary19 bundleAtelier suite — the entry point, router & orchestrator. START HERE when you're not sure which Atelier skill to reach for, want the suite to take a project from where it is to where it should be, or want to set up / read this project's design memory. With no argument it probes project state, decides which skills the situation needs, then RUNS them end-to-end by invoking each skill explicitly with the Skill tool (full `atelier-*` name) — pausing only for a skill's own creative input (tone, audience, the 8-direction pick), never for step-by-step permission. `/atelier <verb> [target]` dispatches to a specific atelier-* skill; `/atelier init` writes the project's ATELIER.md design memory; `/atelier help` shows the full stage-organized menu. Use when the user says "use Atelier", "set up Atelier", "what should I do next on this design", "build this for me", "which atelier skill do I use", or invokes /atelier directly. For a concrete single task the specific atelier-* skill still triggers on its own; this is the hub
- ▌ Forge Uv · luminary19 bundleForge suite — UV unwrapping, seam placement, island packing, texel density normalization, UDIM tile layout, and distortion/checker verification for 3D assets. Produces a validated UV map (non-overlapping bake channel + layout PNG) that downstream baking, material, and export skills can consume without rework. (The project-wide texel-density BUDGET is set in forge-standards; this skill normalizes a mesh's UVs to hit it.) Use whenever UV unwrapping a mesh, placing seams, packing UV islands, normalizing texel density, setting up UDIMs, checking UV stretch or distortion, generating a UV layout PNG, validating UV overlaps, running a checker-map render, preparing UVs for texture baking, or correcting UV scale before export. Trigger phrases: "unwrap", "UV seams", "pack islands", "normalize texel density", "fix UV texel density", "texel density on a UV map", "UDIM", "UV checker", "UV layout", "UV distortion", "UV stretch", "UV overlap", "UV validation", "bake UVs", "lightmap UV", "UV scale". HEADLESS-ONLY: driven fro
- ▌ Forge Rig · luminary19 bundleForge suite — armatures, IK/FK, skinning/weights, and blend shapes / morph targets. Build a complete character or mechanical rig: create bone hierarchies, add IK (inverse kinematics) or FK (forward kinematics) constraints, bind a mesh with automatic or manual weights, enforce the 4-influence game-ready limit, AUTHOR shape keys / morph targets and their corrective drivers (facial FACS / ARKit-52 / corrective — the *animation* of those shapes is forge-animate), and export a verified rig to glTF / FBX / USD. Use whenever asked to rig a character, add bones, weight paint, skin a mesh, set up IK chains, add or author blend shapes, morph targets, shape keys, corrective shapes, or pose/deform a mesh for animation. Hands off to forge-animate for keyframing, shape-key/morph *animation*, and NLA baking; to forge-export for final format export; to forge-validate for the gate. HEADLESS-ONLY: driven from code via bpy Python scripts, output verified by reading a PNG. Part of the Forge suite.
- ▌ Forge Sim · luminary19 bundleForge suite — simulation bake and export skill. Bakes cloth, rigid bodies, soft bodies, particle systems, hair/fur (GN Curves), and Mantaflow fluid/smoke/fire headlessly in Blender, then exports to Alembic (.abc) or OpenVDB (.vdb) mesh-cache for downstream rendering and handoff. Use whenever simulating cloth on a character or fabric, running rigid body destruction or stacking, emitting particles or object-scatter, grooming hair or fur with Geometry Nodes, baking smoke/fire volumes, or exporting any physics cache. Trigger phrases: "bake cloth", "cloth simulation", "rigid body", "particle system", "bake particles", "hair simulation", "fur grooming", "smoke sim", "fire simulation", "fluid simulation", "bake physics", "Alembic cache", "mesh cache", "point cache", "VDB export", "sim bake", "dynamics". All bakes run Blender headless; the result is verified by rendering a QA PNG and reading it. HEADLESS-ONLY: driven from code, output verified by reading a PNG. Part of the Forge suite.
- ▌ Atelier UX · luminary19 bundleAtelier suite — the UX architecture & flows layer (planning-first). Decide how a product is STRUCTURED before any page is styled: the information architecture (content/feature inventory, grouping, sitemap, labels in the user's words), the navigation model (top-nav / sidebar / tab-bar / hub-and-spoke, URL structure, breadcrumbs, search), the critical user flows (signup → activation, the core task, checkout) with their dead-ends and decision points, and the five states every screen must handle (ideal / empty / loading / error / partial). Produces an IA + Flow artifact — analogous to the Direction Doc — that atelier-layout realizes as page structure and atelier-components builds. Use whenever structuring a new app/product/site, deciding what pages or screens exist and how they connect, designing a user flow, journey, navigation model, sitemap, onboarding/activation, or progressive disclosure — or when a product feels confusing, disorganized, or full of dead-ends. Runs right after atelier-direction: ux owns struc
- ▌
- ▌ Forge Brief · luminary19 bundleForge suite — define the 3D asset brief and write FORGE.md (the project-memory file every other Forge skill reads). Produces: a completed FORGE.md at the project root with target engine, coordinate system, poly/texel budgets, render settings, PBR workflow, the determinism contract (seed + sample counts for idempotent rebuilds), output paths, and (when ATELIER.md is present) the extracted world/aesthetic/signature-moment/OKLCH-hue that drives look-dev. Use this FIRST whenever starting any Forge 3D pipeline — including "define the asset", "set up a 3D project", "what are the budgets for this mesh", "create FORGE.md", "brief a 3D asset", "extract the aesthetic from ATELIER.md for Blender", "what engine is the target", "set poly budget", "set texel density", "configure render engine". (The bare "init Forge" / "forge init" phrase is owned by the `forge` router's `init` mode, which scaffolds FORGE.md inline and then calls this skill — this skill does not claim that trigger.) HEADLESS-ONLY: driven from code, output
- ▌ Forge Light · luminary19 bundleForge suite — lighting rigs, HDRI/IBL, and color management for headless 3D renders. Delivers studio-quality, physically-correct lighting setups (three-point area-light rigs, IBL/HDRI world environments, turntable/catalog rigs, shadow catchers, cycloramas, and light linking) plus truthful color management (AgX/ACES/OCIO, texture color-space tagging, false-color QA). Use whenever setting up lights for a Blender scene, choosing a view transform (AgX vs ACES vs Standard), wiring an HDRI environment texture, configuring color management for a render, fixing blown-out or washed-out renders, or verifying exposure with a false-color pass. Covers: "light the scene", "add a three-point rig", "studio lighting", "HDRI setup", "IBL", "PolyHaven HDRI", "shadow catcher", "rim light", "AgX tone mapping", "ACES pipeline", "OCIO config", "color space", "Non-Color texture", "exposure stops", "false color pass", "color management mismatch". HEADLESS-ONLY: driven from code, output verified by reading a PNG. Part of the Forge sui
- ▌ Forge Model · luminary19 bundleForge suite — polygonal and box modeling via Blender bpy + bmesh + modifier stacks. Produces a clean, export-ready .blend/mesh datablock (quad base mesh + non-destructive modifier stack) plus a headless QA render PNG: primitives, extrude, inset, bevel, loop cuts, bridge loops, modifier stacks (Mirror, Array, Solidify, Bevel, Subsurf, Shrinkwrap, WeightedNormal, SmoothByAngle), depsgraph-evaluated geometry reads, and programmatic mesh validation. Use whenever asked to "model a polygonal mesh", "box-model a character/prop", "model a hard-surface/organic mesh", "make a hard-surface asset", "create a base mesh", "add bevel", "add subdivision", "add array modifier", "add mirror modifier", "extrude/inset faces", or "sculpt base". For a toleranced mechanical part use forge-parametric; for scatter/L-system/SDF use forge-procedural; for retopo/LOD/topology repair use forge-topology. Hands off to forge-uv (seams), forge-material (PBR shading), forge-topology (retopo/LOD), forge-render (headless QA render), and forge-va
- ▌ Atelier Copy · luminary19 bundleAtelier suite — the UX-writing & microcopy layer. The words inside the interface are part of the design: button and action labels, form labels and helper text, error messages, empty-state and loading copy, confirmation and destructive-action dialogs, tooltips, onboarding lines, and notifications. Write copy that's clear, human, specific, and on-voice — verb-first actions, errors that say what happened + why + how to fix it, empty states that onboard, no jargon-as-label, no duplicate CTA intents, no fake-precise numbers, no AI-cute wordplay. Use whenever writing or fixing interface copy, microcopy, error/empty/loading text, labels, button text, or when the wording feels generic, confusing, robotic, or off-brand. This owns the WORDS only — which screens/states exist is atelier-ux, their production behavior (overflow, locale, validation) is atelier-harden, and the markup is atelier-components. Part of the Atelier suite.
- ▌
- ▌ Forge Export · luminary19 bundleForge suite — format matrix, glTF/GLB/USD/FBX export, and engine import conventions. Produces a validated, engine-ready asset (GLB, USDC, FBX, or USDZ) from any Forge working file. Use whenever: exporting a Blender scene or procedural mesh to glTF/GLB; converting FBX, OBJ, or STL to GLB; building a USD stage for multi-DCC pipeline; packaging USDZ for iOS AR / Quick Look; importing a GLB into Unreal Engine (Interchange, Nanite, FBX naming), Unity (FBX/glTFast, ORM pack, axis bake), or Godot 4 (headless --import, sidecar .import, collision suffixes); fixing 100× FBX scale; choosing between glTF, USD, FBX, OBJ, Alembic, STEP for a given pipeline stage; or producing a web-ready GLB and handing it to forge-optimize for the atelier-webgl handoff (forge-optimize owns the final Skill(atelier-webgl) call). HEADLESS-ONLY: driven from code, output verified by reading a PNG. Part of the Forge suite.
- ▌ Forge Intake · luminary19 bundleForge suite — physical-world and AI-world 3D intake. Converts real-world photo sequences into production-ready meshes or Gaussian splats (photogrammetry via COLMAP/Meshroom/ RealityScan), trains and exports Gaussian-splat / NeRF scenes (gsplat, Nerfstudio Splatfacto), and turns AI-generated raw geometry into clean, game-ready assets (Meshy/Tripo/TripoSR/Hunyuan3D → retopology + UV unwrap + texture rebake → GLB/FBX). Use whenever you need to: process a photo scan, run photogrammetry, reconstruct a 3D scene from images, train a Gaussian splat, convert a .ply splat file, generate 3D from a text prompt or reference image, clean up a raw AI-generated or scanned mesh, retopologise a dense scan, rebake textures off a raw scan, fix non-manifold geometry on raw capture, or make a raw scan/AI mesh game-ready. This is the INTAKE gate for raw scan/AI geometry only — for retopo/decimation/LOD of an EXISTING clean mesh use forge-topology; for PBR baking on a clean mesh use forge-texture. Produces validated GLB/FBX/PLY read
- ▌ Forge Render · luminary19 bundleForge suite — headless rendering engine and QA eyes. Drives Blender (Cycles/Workbench) to produce render outputs without a GUI: beauty stills, render passes/AOVs (normals, depth, AO, wireframe, UV checker), turntable sequences, 6-view orthographic sheets, and assembled contact-sheet PNGs that the model reads back to verify geometry, shading, and UV quality. Use whenever rendering a 3D asset to PNG, generating a QA contact sheet, setting up Cycles passes, enabling AOVs, doing a turntable render, checking normals or wireframe headlessly, verifying materials or UV unwraps visually, or running any render → Read → critique → fix loop. Triggers: "render the model", "turntable", "contact sheet", "wireframe render", "normal pass", "AO pass", "render passes", "headless render", "Cycles render", "QA render", "render and check", "AOV", "render to PNG". HEADLESS-ONLY: driven from code, output verified by reading a PNG. Part of the Forge suite.
- ▌ Atelier Webgl · luminary19 bundleAtelier suite — 3D, WebGL & shader craft (the flagship layer). Build award-grade 3D and generative graphics: React Three Fiber + Drei scenes, hand-written GLSL/TSL shaders (fresnel, fbm noise, mesh gradients, distortion, dithering), WebGPU via WebGPURenderer, Spline integration, Gaussian splatting, faux-3D, and WebGL image hover/scroll distortion — always with lazy-loading, static fallbacks, and accessibility. Use whenever building 3D scenes, WebGL/Three.js/R3F, shaders/GLSL, a 3D or generative hero, product viewers, shader gradients/grain/distortion, Spline scenes, Gaussian-splat / radiance-field scenes, or interactive 3D graphics. Default stack: React Three Fiber + Drei; vanilla Three.js / OGL for non-React or shader-only work. Gate everything with atelier-perf-a11y. Part of the Atelier suite.
- ▌ Forge Animate · luminary19 bundleForge suite — animation craft layer. Authors keyframes and F-curves, sets interpolation and easing (BEZIER/BACK/ELASTIC/BOUNCE), builds NLA clip libraries, bakes IK/constraint/sim motion to raw TRS keys, and exports skeletal + morph (blend-shape) animation to glTF/GLB, FBX, and USD formats — all headlessly from bpy Python. Use whenever animating objects or armatures, setting up keyframes, editing F-curve handles, choosing easing (ease-in-out, overshoot, bounce, spring), creating looping idles (Cycles modifier), adding camera shake (Noise modifier), baking IK/constraints before export, building NLA multi-clip sequences, exporting animated GLB for Three.js/R3F/Godot/Unity/UE5, or producing USD SkelAnimation. Also use for morph target / shape-key animation. Web/mobile compression of the exported GLB is forge-optimize's job (always Meshopt, never Draco, for animated/morph assets) — this skill hands off to it, it does not run gltf-transform itself. Run = call the Skill tool with the exact name. Saying "now run for
- ▌ Forge Texture · luminary19 bundleForge suite — texture baking and procedural texture authoring (the lookdev texture layer). Bakes normal maps, ambient occlusion, curvature, displacement/height, and combined PBR map sets from a high-poly source onto a low-poly mesh with cage support — headlessly via Blender + Cycles. Also builds procedural shader networks (Noise/Voronoi/Wave/Gradient nodes) and bakes them to tileable PNGs, generates PBR map sets from a single albedo image, downloads CC0 textures from PolyHaven or ambientCG, and compresses finals to KTX2 or WebP. Use whenever asked to: bake textures, bake normals, bake AO, high-poly to low-poly bake, cage bake, transfer detail from sculpt, bake curvature map, bake displacement or height map, bake PBR maps, build a procedural material and bake it, convert height to normal, make a tileable texture, compress textures to KTX2, flip normal map green channel for Unreal/DirectX, download a free PBR texture, or generate a seamless texture. HEADLESS-ONLY: driven from code, output verified by reading a
- ▌ Atelier Harden · luminary19 bundleAtelier suite — the production-resilience pass. Make a beautiful build survive the real world: text overflow and truncation at every breakpoint, internationalization (30-40% text expansion, RTL mirroring via logical properties, locale-aware number/date/currency formatting, pluralization), the full set of error states (per-HTTP-status, offline, timeout, partial failure, form validation), empty and edge-case data (zero / one / few / many / huge, null fields, long strings, broken images), and interaction resilience (double-submit guards, race conditions, AbortController cleanup, no memory leaks). Use whenever hardening or shipping to production, handling edge cases, adding error/empty states, fixing text overflow or i18n/RTL, or making a UI robust under real, messy, translated, or failing data. This owns the BEHAVIOR and markup of error/empty/edge states; the WORDS in them are atelier-copy. Runs after the build and before the atelier-perf-a11y gate. Part of the Atelier suite.
- ▌ Atelier Layout · luminary19 bundleAtelier suite — premium layout & composition. Structure pages and sections so they read intentional and "expensive": choose the right layout archetype, build it with modern CSS (Grid, Subgrid, Flexbox, container queries), apply composition models (rule of thirds, F/Z patterns, asymmetry/broken grid), use Gestalt grouping and clear visual hierarchy, and deploy generous active whitespace. Use this whenever laying out a page or section, building a grid / bento / dashboard / hero, making something responsive, or when a layout feels cramped, flat, centered-and-boring, or templated. Run after atelier-direction (layout archetype) using atelier-foundations spacing tokens.
- ▌ Atelier Motion · luminary19 bundleAtelier suite — motion & micro-interactions (the "feel" layer). Add animation that reads premium, not gimmicky: correct easing/spring defaults, the right durations, the 12 animation principles applied to UI, component/gesture/layout/exit animation with Motion (motion/react), micro-interactions (buttons, toggles, likes), and the often-skipped states (skeleton/shimmer, optimistic UI, empty/loading/error). Use whenever adding or fixing UI animation, transitions, hover/press feedback, loading states, or when motion feels janky, abrupt, excessive, or cheap. Default stack: Motion for React UI — with Anime.js v4 / native CSS / GSAP for vanilla & non-React work, and Lottie / Rive for designer-authored assets; defer scroll-driven work to atelier-scroll and pre-ship checks to atelier-perf-a11y. Part of the Atelier suite.
- ▌ Atelier Review · luminary19 bundleAtelier suite — the adversarial pre-ship review. A full multi-step red-team of a FINISHED frontend build: fan out independent reviewers across dimensions (accessibility, performance, motion/reduced- motion, design-integrity/anti-slop, code quality), adversarially verify every finding to kill false positives, verify live in a real browser, synthesize a prioritized fix list, apply serially, and re-verify. Built to run with the ordinary Task/subagent tool — it does NOT require ultracode/Workflow. Use whenever a substantial build is "done" and needs a real audit before shipping, when asked to review / red-team / audit / "is this ready to ship" / find problems / pre-ship review a frontend. This is the heavyweight, adversarial counterpart to the atelier-perf-a11y self-checklist. Part of the Atelier suite.
- ▌ Atelier Scroll · luminary19 bundleAtelier suite — scroll choreography & advanced interaction. Build award-grade scroll experiences: smooth/inertia scroll (Lenis), scroll-triggered reveals, scrubbing, pinning, horizontal sections, sticky-stacking cards, parallax, native CSS scroll-driven animations, page/route transitions (View Transitions API), infinite marquees, magnetic buttons, and custom cursors. Use whenever adding scroll-based animation or storytelling, smooth scrolling, parallax, pinned/horizontal sections, page transitions, marquees, or custom/magnetic cursors — or when scroll feels static, abrupt, or janky. Default stack: GSAP + ScrollTrigger + Lenis, with native CSS scroll-driven animations as progressive enhancement. Honors prefers-reduced-motion. Part of the Atelier suite.
- ▌ Codex Imagegen · luminary19 bundleGenerate and edit raster images by driving the locally-installed OpenAI Codex CLI headlessly and invoking its FIRST-PARTY built-in `image_gen` tool (gpt-image) — using the ChatGPT Plus/Pro login Codex is already authenticated with, NO OpenAI API key, no reverse-engineered routes. Use when asked to "generate an image", "make a logo/icon/ texture/mockup", "edit this PNG", "use codex to create an image", or "/codex-imagegen". Wraps `codex exec` and parses output via a PowerShell helper so files are reliably found.
- ▌ Forge Material · luminary19 bundleForge suite — PBR shading, glTF material model, and Blender Principled BSDF authoring (the lookdev layer). Produces verified Blender materials and glTF-export-ready (round-trip-checked) node graphs with correct metal/rough maps, ORM channel packing, normal maps, and glTF KHR extension wiring — the shipping GLB itself is emitted by forge-export — then renders to PNG for visual QA via Cycles headless. Use whenever authoring or debugging PBR materials, setting metallic/roughness/IOR/clearcoat/transmission/sheen/anisotropy, building Principled BSDF node graphs in Python (bpy), packing ORM textures, exporting glTF/GLB with correct material settings, wiring KHR_materials_clearcoat / KHR_materials_transmission / KHR_materials_volume / KHR_materials_emissive_strength / KHR_materials_anisotropy / KHR_materials_iridescence, converting DirectX to OpenGL normal maps, diagnosing sRGB/non-color space errors, validating glTF material output with gltf-validator, or understanding the Blender→glTF Principled BSDF mapping table
- ▌ Forge Optimize · luminary19 bundleForge suite — web/runtime optimization pipeline for 3D assets: compress, budget, and hand off GLB files to the browser. Takes a raw GLB exported by Blender (or another DCC) and delivers a browser-ready GLB with Draco or Meshopt geometry compression, KTX2/Basis Universal or WebP texture compression, mesh quantization, LOD generation, and spec-validation — then produces the handoff package that atelier-webgl expects (optimized GLB + poster WebP + decoder paths). Use whenever: compressing a GLB for web delivery, reducing file size, applying Draco or Meshopt, encoding KTX2 textures with UASTC or ETC1S, generating LOD levels from a GLB, setting up DRACOLoader / KTX2Loader / MeshoptDecoder in Three.js or R3F, validating a GLB against the Khronos spec, building a before/after size report, running gltf-transform or gltfpack, meeting web 3D budget targets (< 3 MB, < 100 draw calls, < 500k triangles), or preparing assets for the atelier-webgl handoff. Trigger phrases: "optimize GLB", "compress 3D model", "Draco compres
- ▌ Forge Topology · luminary19 bundleForge suite — topology & edge-flow discipline. Audit, repair, and enforce mesh quality before any downstream work (subdivision, rigging, baking, export, booleans). Produces: JSON topology report, auto-repaired mesh, wireframe QA PNG, LOD chain GLBs, and boolean-cleaned geometry. Use whenever you need to: audit topology, fix non-manifold geometry, check or place poles, enforce quad flow, retopologize a high-poly mesh, generate an LOD chain, decimate for web/game budgets, run QuadriFlow or Voxel remesh, bake high-to-low normals, repair after a boolean operation, validate watertightness, apply a TRS or axis-swap to an existing mesh, serialize a quaternion for export, or bake handedness/ up-axis conversion into the geometry before export. Defining the project-wide coordinate system, handedness, scale unit and pivot rules is **forge-standards**'s job — this skill OPERATES on a mesh, it does not set the standard. Also triggers on: "bad normals", "flipped faces", "ngon cleanup", "LOD0 LOD1 LOD2", "simplify mesh", "r
- ▌ Forge Validate · luminary19 bundleForge suite — the quality gate every asset must pass before it is considered done. Runs manifold/watertight checks, normal consistency, scale/units, polycount budgets, UV checks (presence, range, texel-density), glTF-Validator spec compliance, printability (wall thickness, overhang, drain holes via `--print`), render-QA (Workbench contact sheet + verified Read pass), and adversarial escalation via independent sub-reviewers. Use whenever finishing a 3D asset, before export or handoff, running a mesh audit, checking if a GLB is spec- valid, confirming a model is print-ready, or reviewing render output for defects. This is the canonical gate other Forge skills reference for validation rules. HEADLESS-ONLY: all rendering is non-interactive, output verified by reading a PNG. Part of the Forge suite.
- ▌ Atelier Dataviz · luminary19 bundleAtelier suite — the data-visualization layer. Turn data into charts that read clear and premium, not rainbow slop: choose the right chart for the question, encode values honestly (position > length > color), build on the house stack (shadcn Charts/Recharts → Tremor → visx/D3 → ECharts), strip to signal (restrained axes/legends/grid, direct labels, tabular number formatting), and ship ACCESSIBLE charts (keyboard, data-table fallback, real alt/aria, reduced-motion) — because canvas/SVG is invisible to screen readers. Use whenever building or fixing a chart, graph, plot, sparkline, KPI/metric/stat, gauge, heatmap, or the data *inside* a dashboard — or when a visualization looks cluttered, misleading, 3-D, or generic. Pulls categorical/sequential/diverging palettes from atelier-foundations; the dashboard *shell* + KPI-card layout is atelier-components; gated by atelier-perf-a11y. This is the canonical home for charting craft — prefer it over reaching for a chart lib blindly. Part of the Atelier suite.
- ▌ Forge Standards · luminary19 bundleForge suite — the "3D design tokens" layer. Defines and enforces every project-wide 3D constant before any geometry or texture is authored: coordinate system and handedness per export target (Blender Z-up RH → glTF/Three.js Y-up RH vs. Unreal Z-up LH → FBX), unit scale (meters in Blender, cm in UE5, the 100× correction), axis-swap matrices, real-world scale references, naming conventions (SM_/SK_/T_/M_/MI_ prefixes, _BC/_N/_ORM texture suffixes), pivot/origin placement rules per object class, per-platform polycount budgets (PC/console/mobile/web), texel density targets (px/m), UV utilization floors, ORM channel-pack policy, LOD ratios, and FORGE_STANDARDS.json schema. Use whenever DEFINING the 3D standards for a project (after the brief writes FORGE.md), resolving a "sideways mesh" or "100× scale" bug, establishing naming rules, budgeting polys or texel density, deciding pivot placement for a prop type, or generating the machine-readable standards file that other Forge skills ingest. Bootstrapping a brand-new
- ▌ Atelier Redesign · luminary19 bundleAtelier suite — audit & upgrade existing sites/apps to premium without breaking them. Audit-first: inventory the current brand/IA/stack, name the specific AI-slop tells and the missing "expensive" levers, score gaps by impact vs risk, then apply the Atelier suite (direction → foundations → type → layout → motion → components → scroll/webgl) selectively, preserving functionality, content, SEO, and accessibility, and verifying with the perf/a11y gate. Use whenever improving, modernizing, polishing, or redesigning an existing website or app, fixing a design that looks dated/generic/templated/cheap, or doing a UI audit. This is the front door for EXISTING-site work — start here rather than atelier-direction when the site/app already exists; it brings the rest of the suite (direction included) in as needed. Supersedes older redesign skills. Default stack: Tailwind v4 + shadcn. Part of the Atelier suite.
- ▌ Forge Parametric · luminary19 bundleForge suite — Code CAD: produce engineering-grade solid geometry headlessly from code. Deliverables: STL, 3MF, STEP, GLB files with exact fillets/chamfers, ISO tolerances & fits, threads, draft angles, and ribs — verified by rendering a PNG and reading it back. Use whenever asked to: design a part, model a mechanical component, create a parametric CAD file, generate a bracket/enclosure/housing/fixture, export STEP or STL for 3D printing, design threads or screw fits, apply fillets or chamfers to a solid, specify ISO tolerances or engineering fits (H7/p6 etc.), batch-generate design variants with different dimensions, convert between CAD formats, or produce a solid model from a sketch/spec. Triggers on: "OpenSCAD", "CadQuery", "build123d", "FreeCAD", "STEP export", "STL export", "3MF", "fillet", "chamfer", "tolerance", "clearance fit", "press fit", "threaded rod", "nut", "bolt", "BOSL2", "parametric model", "print-ready part", "CAD script", "solid model". HEADLESS-ONLY: driven from code (.scad / .py), output v
- ▌ Forge Procedural · luminary19 bundleForge suite — procedural geometry craft skill. Build mesh from code, not hand-modeling: Blender Geometry Nodes scripted via Python (scatter, greeble, curve-sweep, noise displacement), SDF/implicit surfaces (fogleman/sdf, marching cubes, dual contouring, gyroid/TPMS), and generative systems (L-system branching, Wave Function Collapse modular kit-bash). Use whenever the task is "generate geometry procedurally", "scatter objects on a surface", "grow a tree/plant/coral structure", "create a gyroid or lattice infill", "make a greeble detail pass", "build a modular tileset", "implicit surface", "SDF", "Geometry Nodes from Python", "parametric scatter", or "seeded reproducible geometry". Output is a headless-rendered PNG (Cycles CPU) for visual QA plus GLB/STL/OBJ for downstream use. HEADLESS-ONLY: driven from code, output verified by reading a PNG. Part of the Forge suite.
- ▌ Atelier Direction · luminary19 bundleAtelier suite — the art-direction brain. Decide the design direction BEFORE writing any frontend code: which aesthetic, which "world" (production vs award-grade), the concept, the palette mood, type voice, motion budget, layout archetype, and signature moment. Produces a Direction Doc scaled to the task (a one-line read for small tweaks, a full one-pager for substantial builds/redesigns) that the rest of the suite (atelier-foundations, atelier-typography, atelier-layout) consumes. This is the canonical Atelier entry point — prefer it over older/general design skills. Use this FIRST whenever building a new website, landing page, web app, dashboard, portfolio, or editorial site — or deciding the look/feel/aesthetic of one — and ESPECIALLY whenever frontend output risks looking generic, templated, or "AI-made." If the user mentions design, UI, a new page, a look/vibe, an aesthetic, names a reference site, or wants to see several distinct creative directions to choose from (a moodboard of options), start here. Fo
- ▌ Atelier Perf A11Y · luminary19 bundleAtelier suite — the performance & accessibility gate. The cross-cutting quality bar every Atelier build passes before it ships: animate only compositor-safe properties, hit Core Web Vitals (LCP ≤2.5s, CLS ≤0.1, INP ≤200ms), respect prefers-reduced-motion, meet WCAG 2.2 AA (contrast, focus, keyboard, target size, semantics, screen readers), give canvas/WebGL accessible fallbacks, and run the anti-slop "AI Tells" design-integrity check. Use whenever finishing or reviewing a frontend, optimizing performance / Core Web Vitals / Lighthouse, fixing jank or layout shift, doing an accessibility/a11y audit, handling reduced motion, running a pre-ship check, or checking whether a build reads as AI-generated/templated. This is the canonical home for the perf/a11y rules the other Atelier skills reference. Part of the Atelier suite.
- ▌ Atelier Components · luminary19 bundleAtelier suite — turn the design system into real, accessible, production code. Scaffold a premium React/Next + Tailwind v4 + shadcn/ui project, wire the atelier-foundations tokens into shadcn's theme variables, install the best-in-class single-purpose components (Vaul drawer, Sonner toast, cmdk command palette, Tremor dashboards), set up Storybook, and assemble pages from a copy-paste premium section-block library (hero variants, bento, feature rows, pricing, nav, footer, dashboard shell, data tables, forms, empty states). Use whenever building/scaffolding a frontend project, implementing components or page sections, setting up shadcn/Tailwind, adding a drawer/toast/command-palette/charts, or assembling marketing or app UI. Default stack: React/Next + Tailwind v4 + shadcn — with a no-framework path (Basecoat / Franken UI) for vanilla HTML / Rails / Laravel / Django / Astro. Part of the Atelier suite.
- ▌ Atelier Typography · luminary19 bundleAtelier suite — expensive typography. Choose and pair fonts with a point of view, build a fluid modular type scale, control tracking/leading/measure, switch on the right OpenType + variable-font features, set editorial detail (drop caps, pull quotes, hierarchy), tune font loading for zero layout shift, and animate type (kinetic / scroll-driven) tastefully. Use this whenever typography matters: picking or pairing fonts, headings that feel generic or "default Inter/Playfair," body readability, display type, variable fonts, font loading / FOUT / web-font CLS, RTL & non-Latin (CJK) type, numbers in tables, or animated/kinetic text. Run after atelier-direction (type voice) and alongside atelier-foundations (which owns the scale tokens).
- ▌ Atelier Foundations · luminary19 bundleAtelier suite — the design-system engine. Build the token foundation that makes a frontend look coherent and "expensive": a perceptual OKLCH color system (ramps + semantic tokens + accessible dark mode), a modular + fluid type scale, an 8-point spacing scale, and depth (radii, shadows, grain). Outputs ready-to-use CSS custom properties, Tailwind v4 @theme (mapped to shadcn/ui theme variables), or W3C/DTCG design tokens. Use this whenever starting any frontend that needs a consistent visual system, when building a color palette / design tokens / chart & data-viz palettes / theme / dark mode, or when colors, spacing, or sizing feel inconsistent, muddy, or generic. Run after atelier-direction; before building components. (Choosing and setting the actual fonts → atelier-typography; scaffolding and building components → atelier-components.)
- ▌ Codex Imagegen Taste · luminary19 bundlePremium, anti-slop DESIGN layer over /codex-imagegen: turn a brief into an art-directed, one-image-per-section website comp (landing page, hero, full mockup, design reference) by injecting a taste preamble + a locked house style into EACH call of the codex-imagegen helper. This is the BRAIN (what to draw, how, anti-slop); /codex-imagegen stays the HANDS (renders key-free via the local Codex CLI and finds the PNG). Use when asked for a "landing page mockup", "full website comp", "hero image", "premium UI mockup", "design reference image", or "make a nice <page> image". DEFER to bare /codex-imagegen for a quick moodboard, a single abstract sketch, a simple icon/texture/logo, or atelier-direction's 8-direction board - those do NOT need the taste layer.