PluginBench
Skill
Pass
Audit score 90

threejs-aaa-graphics-builder

majidmanzarpour/threejs-game-skills

Upgrade Three.js games from prototype to AAA-quality browser graphics with procedural models, materials, shaders, and render optimization.

What is threejs-aaa-graphics-builder?

A production graphics pass system for Three.js games that transforms basic visuals into high-fidelity, performance-aware scenes. Use it when your game screenshots look prototype-level or when you need premium, showcase-quality visuals with authored forms, material libraries, lighting, VFX, and render budgets.

  • Score visuals against a 10-category AAA benchmark and identify weakest surfaces
  • Build procedural models, material libraries, and world prop kits in Three.js
  • Author shaders, post-processing, and VFX systems tied to gameplay state
  • Optimize render pipelines with LOD, instancing, and performance budgets
  • Upgrade lighting, tone mapping, shadows, and fog for premium tone
  • Integrate external generated assets (3D models, textures, skies) or stay fully procedural

How to install threejs-aaa-graphics-builder

npx skills add https://github.com/majidmanzarpour/threejs-game-skills --skill threejs-aaa-graphics-builder
Prerequisites
  • Three.js project with an active playable scene or screenshots
  • Optional: API credentials for external 3D/image generation (if using procedural generation beyond Three.js)
  • Access to the skill's reference files (visual-scorecard, authoring-recipes, technical-art, shader-cookbook)
Claude Code
Cursor
Windsurf
Cline

How to use threejs-aaa-graphics-builder

  1. 1.Capture or inspect active-play screenshots on your target viewports
  2. 2.Score the affected views using the visual-scorecard reference and identify the weakest surfaces
  3. 3.Read the relevant reference files (authoring-recipes for models/lighting, technical-art for performance, shader-cookbook for custom shaders)
  4. 4.Build authored forms first (procedural models or generated assets), then apply materials, then lighting, then effects
  5. 5.Upgrade every visible surface: hero assets, hazards, rewards, ground, props, backgrounds, and telegraphs
  6. 6.Add lighting, tone mapping, and render polish once forms are complete
  7. 7.Integrate event-driven VFX tied to gameplay state
  8. 8.Re-score against the calibration anchors and iterate until all premium categories meet your target

Use cases

Good for
  • Transform a basic prototype game into a polished, high-fidelity browser experience before launch
  • Add premium hero assets (characters, vehicles, environments) and upgrade all visible surfaces systematically
  • Establish material roles, lighting architecture, and render budgets for a new game from the start
  • Diagnose and fix performance bottlenecks while maintaining visual quality on target viewports
  • Create authored VFX and state-driven effects that respond to gameplay events
Who it's for
  • Game developers building Three.js browser games who want production-quality visuals
  • Technical artists optimizing render pipelines and material systems
  • Teams upgrading prototype graphics to AAA or showcase quality
  • Developers balancing visual fidelity with browser performance constraints

threejs-aaa-graphics-builder FAQ

When should I use this skill?

Use it when your game screenshots still look basic, or when the user explicitly asks for premium, AAA, high-fidelity, showcase, or less-basic graphics. It is a production graphics pass, not a quick polish.

Do I need external asset generation, or can I stay fully procedural?

You can stay fully procedural with Three.js; the skill supports both paths. External generation (via threejs-image-generator or threejs-3d-generator) is optional for hero surfaces and high-value 2D assets. Run the credential probe if you choose external generation.

What is the core rule for AAA graphics?

Glow does not make primitives look AAA. Build authored forms first, then materials, then lighting, then effects — in that order. Skipping form authorship and jumping to effects will not achieve premium visuals.

How do I measure progress and know when I am done?

Use the 10-category visual scorecard to score before and after. Re-score after each major pass (forms, materials, lighting, VFX) and cite measured metrics from the renderer diagnostics. Keep iterating until every premium category is at least a 2, or name the exact blocker preventing further improvement.

What if asset generation times out or fails?

A single timeout is not evidence that generation is unavailable. Consult the director's asset-recovery reference for failure handling. Procedural Three.js can always handle repeated props, collision proxies, VFX geometry, and instanced volume as fallbacks.

Full instructions (SKILL.md)

Source of truth, from majidmanzarpour/threejs-game-skills.


name: threejs-aaa-graphics-builder description: "Upgrade Three.js games from prototype visuals to premium browser graphics: art-direction critique, procedural model building, material and texture libraries, world prop kits, shaders, VFX, lighting and render pipeline, LOD and instancing, render budgets, and a 10-category visual scorecard. Use when screenshots still look basic or the user asks for premium, AAA, high-fidelity, showcase, or less-basic graphics."

Three.js AAA Graphics Builder

Own the production graphics pass: turn basic screenshots into authored, high-density, performance-aware visuals.

References

FileRead it when
references/visual-scorecard.mdscoring visuals or making any premium/AAA/showcase claim
references/authoring-recipes.mdbuilding hero, obstacle, reward, world-kit, or prop models; changing lighting, tone mapping, shadows, fog, post, or graphics architecture
references/technical-art.mdrender budgets, material kits, VFX systems, instancing/LOD, imported asset cleanup, anything that could affect browser performance
references/shader-cookbook.mdcustom shaders, onBeforeCompile, skies, or post-processing; use recipes as tested starting points and verify them against the project's Three.js version

For a broad "still looks basic" or premium pass, read all four before implementing. A narrow graphics edit loads only its relevant references and checks; the requested style and scope override recipe defaults.

Core rule

Glow does not make primitives look AAA. Build authored forms first, then materials, then lighting, then effects — in that order.

Workflow

  1. Capture or inspect active-play screenshots on the target viewports when a playable scene exists.
  2. For an existing game, score the affected views and pick the weakest surfaces. For a new game, establish art direction, camera scale, material roles, and the hero target first; do not invent a before screenshot.
  3. Add the graphics architecture the game is missing: material library, procedural textures and decals, model factories, world prop kit, VFX system, render pipeline, diagnostics.
  4. Choose a source per high-value surface: procedural Three.js, a threejs-image-generator reference or texture, a threejs-3d-generator model, or an image-to-3D hybrid chain. Run the credential probe when external generation is in scope. Inspect the concept/model before dependent generation or rigging. Finish one representative playable scene with actual assets and feedback before expanding the content kit.
  5. Upgrade every weak visible surface, not only the hero: hazards, rewards, ground and track, foreground props, background layers, telegraphs, material variation, state VFX.
  6. Add lighting, tone mapping, and render polish once authored forms exist.
  7. Add event-driven VFX tied to gameplay state.
  8. Re-score against the calibration anchors, citing the inspector's measured metrics. Keep going until every premium category is at least 2, or name the exact blocker.

Asset sourcing

When external generation is in scope, run threejs-game-director/scripts/probe_asset_credentials.sh first; explicitly procedural art needs no probe. With keys set, generate the hero surfaces (player, character, creature, boss, vehicle, ship, building, weapon, signature prop, hero environment piece) and high-value 2D (skies, backgrounds, texture and trim references, decals, faction marks, icons, GUI and title art, image-to-3D inputs), unless the user restricted art to procedural or ruled out external services. Procedural Three.js handles repeated props, kits, collision proxies, VFX geometry, and instanced volume. Handle failures with the director's references/asset-recovery.md; a single timeout is not evidence that generation is unavailable.

For animated assets inspect motion as well as silhouettes: locomotion, blend transitions, foot contacts, hit timing, and secondary motion in real gameplay. A focused independent critique may identify defects after a substantial pass; the lead remains responsible for the final score and integration.

Report

Score before and after with one line of evidence per category, the surfaces you upgraded, files changed, screenshots, renderer diagnostics against the budget table, generated asset paths and task IDs, and what is still weak. Include imported-asset diagnostics (scale, bounds, collision proxy, clips) when generated 3D was used.