3D Asset Generation , Blender handling, Unity game development skills for Codex , Claude, Kimi k3, Deepseek4 etc.

What this repository gives you

This project packages practical AI agent instructions for two difficult production workflows:

The skills are designed for AI game development, vibe coding, Blender automation, Unity MCP, 3D asset generation, 2D game development, and 3D game development. They use the portable SKILL.md pattern and can be adapted to Codex, Claude, Kimi k3, Deepseek4, and other agents that support reusable instruction packages or project-level prompts. Compatibility varies by client; the repository does not claim that every named model has been independently tested.

Created for vibe coders, grounded in production checks

Vibe coding becomes much more useful when the agent has a repeatable definition of “done.” These skills teach an agent to move through a guarded loop:

flowchart LR
    A[Understand the brief] --> B[Inspect tools and project state]
    B --> C[Define budgets and acceptance checks]
    C --> D[Make one reversible production slice]
    D --> E[Wait for import, compile, or evaluation]
    E --> F[Measure and inspect the result]
    F -->|failed gate| D
    F -->|passed| G[Export, build, and report evidence]

That loop is the core mechanic. The skill does not replace Blender or Unity, and it does not magically make every model correct. It gives the AI agent a domain-specific operating system: what to inspect, what to change, which pitfalls to avoid, how to validate, and what evidence to report.

How Agent Skills work

Each skill is a compact package:

skills/
├── blender-3d-asset-generation/
│   ├── SKILL.md                 # Core operating workflow
│   ├── agents/openai.yaml       # Codex/OpenAI-facing metadata
│   ├── scripts/                 # Deterministic Blender QA
│   ├── references/              # Deep, task-specific guidance
│   └── assets/                  # Skill icon
└── unity-mcp-game-development/
    ├── SKILL.md                 # Core Unity + MCP workflow
    ├── agents/openai.yaml
    ├── references/              # 2D, editor, MCP, QA and sources
    └── assets/                  # Icon + custom MCP tool template

The loading model uses progressive disclosure:

sequenceDiagram
    participant U as Vibe coder
    participant A as AI coding agent
    participant S as Skill package
    participant T as Blender / Unity tools
    U->>A: Build this asset or gameplay feature
    A->>S: Load matching SKILL.md
    S-->>A: Workflow, constraints, references
    A->>T: Inspect current state
    T-->>A: Scene, project, console, metrics
    A->>T: Apply a narrow change
    A->>T: Validate, render, test, or build
    T-->>A: Evidence and failures
    A-->>U: Verified result and remaining checks

Installation

Clone the repository:

git clone https://github.com/lovecatisgood-sudo/3d-asset-generation-blender-unity-game-development-skills.git
cd 3d-asset-generation-blender-unity-game-development-skills

Codex

Copy or symlink either skill into your Codex skills directory:

mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills"
cp -R skills/blender-3d-asset-generation "${CODEX_HOME:-$HOME/.codex}/skills/"
cp -R skills/unity-mcp-game-development "${CODEX_HOME:-$HOME/.codex}/skills/"

Restart the client or open a new session so it discovers the skill metadata. Invoke explicitly when desired:

Use $blender-3d-asset-generation to create a game-ready low-poly forest shrine for Unity.
Use $unity-mcp-game-development to inspect my platformer and implement a verified wall-jump.

Claude and other agents

Place each complete skill directory in the agent's supported skills location. If the client does not natively discover SKILL.md, attach or reference the relevant SKILL.md as project instructions and allow it to load only the linked reference files needed for the task.

Never grant an MCP server broader filesystem or Editor access than the current project requires. Confirm the active Blender file or Unity project before mutation.

Blender 3D asset generation workflow

The Blender skill orders work by production risk, not by visual excitement:

flowchart TD
    A[Asset contract] --> B[Reference + scale guides]
    B --> C[Blockout and silhouette]
    C --> D[Production topology]
    D --> E[UVs + materials]
    E --> F{Animated?}
    F -->|Yes| G[Rig + skin + clips]
    F -->|No| H[LOD + collision]
    G --> H
    H --> I[Automated audit]
    I --> J[Export]
    J --> K[Clean re-import]
    K --> L[Turntable + handoff manifest]

How to generate a good 3D asset

Asset quality is multiplicative

A beautiful model with broken scale or export is not game-ready. Think of quality as a chain:

flowchart LR
    S[Silhouette] --> X((×))
    T[Topology] --> X
    U[UV + materials] --> X
    R[Rig + animation] --> X
    P[Performance] --> X
    E[Export integrity] --> X
    X --> Q[Game-ready quality]

If one critical factor approaches zero, the handoff quality collapses. This is why the skill pairs visual review with machine-readable auditing.

Blender audit script

Run the included script with Blender:

blender --background hero.blend \
  --python skills/blender-3d-asset-generation/scripts/audit_blender_asset.py \
  -- --output build/hero-audit.json --max-triangles 25000 --require-uv --require-applied-scale

The report includes object counts, mesh triangles, dimensions, transforms, UV layers, materials, armatures, actions, non-manifold edges, loose vertices, and missing external images. Budget limits are examples only—set them from your actual game and target hardware.

How to make a good Unity 3D game

Good 3D game development is a sequence of playable vertical slices. Start with feel and readability, then scale the world and content.

flowchart LR
    P[Player verbs] --> C[Controller + camera]
    C --> I[Interaction loop]
    I --> L[Greybox level]
    L --> F[Feedback: animation, audio, VFX]
    F --> M[Content systems]
    M --> Q[Tests + profiling + builds]

The Unity skill enforces six production gates: compile, authored state, behavior, tests, runtime build, and target performance.

How to make a good Unity 2D game

2D production has its own technical constraints. Pixel density, sprite pivots, sorting, tile collisions, animation timing, and camera composition affect the feel as much as code.

flowchart TD
    A[Reference resolution + pixels per unit] --> B[Character movement metrics]
    B --> C[Sprites + animation clips]
    C --> D[Tilemap + collision layers]
    D --> E[Camera + sorting + 2D lighting]
    E --> F[Enemies, hazards, pickups]
    F --> G[UI, audio, particles, accessibility]
    G --> H[Play Mode tests + device build]

Build one complete room or short level before producing a large map. A small polished slice exposes movement, import, collision, animation, UI, and build problems while they are still inexpensive to fix.

Blender-to-Unity handoff

flowchart LR
    B[Blender source .blend] --> A[Asset audit]
    A --> X[GLB / glTF / FBX]
    X --> U[Unity import preset]
    U --> P[Prefab + materials]
    P --> S[Gameplay scene]
    S --> T[Play Mode + target build]
    T -->|issue| B

Use a manifest for every important asset:

Example prompts

3D prop

Use $blender-3d-asset-generation to create a stylized game-ready forest shrine for a Unity third-person game. First define scale, pivot, triangle and material budgets. Produce the .blend source, GLB export, simple collision, two LODs, a neutral turntable, and a JSON audit. Re-import the GLB into a clean scene and report any differences.

3D character

Use $blender-3d-asset-generation to prepare this character for real-time gameplay. Preserve the visual identity, repair topology only where needed, create clean UVs, rig and weight it, author idle/run/jump clips, validate extreme poses, export it for Unity, and provide a clip and asset manifest.

Unity 3D vertical slice

Use $unity-mcp-game-development to inspect this Unity project, then build one verified third-person vertical slice with movement, camera, interaction, one enemy, health UI, audio feedback, tests, and a development build. Work in reversible slices and read the Console after every script change.

Unity 2D platformer

Use $unity-mcp-game-development to build a polished 2D platformer room. Establish reference resolution and pixels per unit, implement physics-based movement and coyote time, import the animation set, configure tilemap collision and sorting, add one enemy and collectible, then verify transitions in Play Mode and create a development build.

Safety and honest limits

• MCP is a capability boundary. Enable only the tools needed for the active project.
• Confirm the active Blender file or Unity project when more than one instance exists.
• Inspect before broad mutation and request approval before destructive scene replacement, package migration, or large deletion.
• Keep source files recoverable and avoid editing serialized Unity YAML while the Editor is open unless performing a controlled merge.
• Treat generated geometry, textures, scripts, and gameplay as drafts until they pass visual, structural, legal, and runtime review.
• Check the license and provenance of every third-party model, texture, font, sound, and code dependency.
• “AI-generated” does not guarantee originality, correctness, performance, or freedom from third-party rights.

Credits

Jointly developed and prepared by Siamese Cat Dev and Mr A to help vibe coders build better 3D and 2D games with Unity and prepare production-minded 3D assets with Blender.

The project also builds on the public documentation and work of the Blender, Unity, Python, C#, glTF, Model Context Protocol, and Agent Skills communities. See the official-source files inside each skill for version-aware technical references.

Free DJAI lesson — join the next 1-hour session

Want a guided start instead of reading alone? DJAI.academy offers a free 1-hour lesson. Check the next available time slot and do not miss it:

Reserve/check the next free DJAI 1-hour lesson →

The course page is maintained by DJAI.academy; availability and future time slots may change, so use the page for the current schedule.

Contributing

Bug reports, version updates, workflow improvements, reproducible examples, QA checks, and engine-specific lessons are welcome. Please read CONTRIBUTING.md before opening a pull request.

License

Released under the MIT License. Attribution is appreciated; the repository includes formal creator credits in CITATION.cff.

Discoverability topics

Blender automation · Blender Python · bpy · 3D asset generation · game-ready assets · low-poly modeling · Unity game development · Unity MCP · Unity 2D · Unity 3D · AI game development · vibe coding · Agent Skills · Codex skills · Claude skills · Kimi k3 · Deepseek4 · procedural modeling · glTF export · game dev tools