LLM-Orchestrated Coding Workflow

The eight steps

1. Spec

Write a clear problem statement, measurable acceptance criteria, and why the change matters. For a greenfield MVP, also define one core user flow and an explicit out-of-scope list.

2. Plan

Create an editable plan artifact (for example tasks/todo.md) before writing code. Assign models by role: planner/architect, implementer, reviewer, verifier. Keep context lean. Use sub-agents or parallel worktrees for exploration, clear context between major steps, and prefer small, atomic, reversible units of work.

3. Task Packet

Package each step with an objective, precise scope (files or directories), hard constraints, exact verification commands the agent must run, evidence the agent must produce, and a definition of done. If a step cannot be reviewed or reverted cleanly in minutes, split it.

4. Implement

Send the task packet to the implementing agent. Require code, files changed, a minimal diff summary, commands actually run with full output, unresolved risks, and status against every acceptance criterion. Prefer the agent running verification commands inside the loop.

5. Review

A review role (same or different model) checks correctness, regressions, edge cases, project rules (AGENTS.md, CLAUDE.md, or .cursorrules), and whether the evidence is sufficient. Red-team high-risk changes with a second model when security, auth, data, or payments are touched.

6. Verify

Do not accept a change until lint, type-check, tests, and project-specific commands have been run by the agent or CI and the results appear in the output. Prefer the smallest focused test set that exercises the change.

7. Manual Validate

Run targeted runtime and scenario checks that automation cannot cover. The human still owns final behavioral judgment for non-trivial UX or business logic.

8. Commit

Keep commits tied to completed task packets. Record verification commands and results in the change note. Prefer small, reviewable diffs.

What belongs in repo-level instructions?

Put durable rules in AGENTS.md (or CLAUDE.md / .cursorrules), not in every prompt. That file is the lasting place for conventions, required commands, model roles, review expectations, and definition of done.

• Project conventions and coding standards
• Model roles and review expectations
• Required verification commands and definition of done
• Release and commit formatting rules

Keep each prompt focused only on the current task, scope, and acceptance criteria.

Example task packet

Objective: Add a new endpoint for exporting user settings as JSON.
Scope: backend route only. Files: app/server/users.js and tests/server/users.test.js.
Constraints: preserve current auth flow; do not change UI or adjacent routes.
Commands (agent must run and paste full output):
  npm test -- users.test.js
  npm run lint -- app/server/users.js
  npm run typecheck
Acceptance criteria:
  - GET /users/:id/settings/export returns 200 and valid JSON for an authenticated user
  - unauthorized requests return 401
  - unit tests cover happy path, 401, and error paths
Definition of done:
  - all commands above pass
  - no files outside Scope are modified
Required evidence:
  - files changed + minimal diff summary
  - full command output for each verification command
  - status against every acceptance criterion
  - unresolved risks (or "none")

Review loop checklist

• Correctness: does the change meet every acceptance criterion within the stated scope?
• Regressions: did the review role check edge cases, project rules, and backward-impact risk?
• Evidence: is the claim of done backed by full command output, not just a summary?

Validation and evidence

• The agent (or CI) runs lint, type-check, and tests. The human reviews the evidence, not just the claim of "done".
• Run the smallest focused test set that exercises the change.
• Confirm the output includes files changed, a diff summary, commands run, full command output, unresolved risks, and acceptance criteria status.
• When needed, validate runtime behavior in a representative environment. The human owns that final judgment.

Common failure modes

• Vague prompts: no objective, acceptance criteria, or why it matters.
• Oversized steps: hard to review or revert in minutes.
• Missing reproducible commands: you cannot confirm the change.
• Scope drift: the agent edits unrelated files or expands beyond the task packet.
• Trusting "done" without command output or other evidence.
• Repeating durable rules in every prompt instead of using AGENTS.md.
• Context pollution from long sessions: stale goals, mixed tasks, or uncleared exploration noise.

One manager agent turns your brief into a task board, staffs the smallest useful team, and only reports back with proof. Publishing, sending, buying, deploying, deleting and granting access always wait for your approval.

1. Choose a version and fill in the brief

Pick the wording that matches your LLM. Blank fields keep their {{PLACEHOLDER}}. Everything runs in your browser.

2. Copy the prompt

Copy prompt Clear fields

How to use it

• Paste the prompt as the first message to your manager agent.
• Answer the single blocking question, if one is asked, then review the proposed team before work starts.
• Judge progress on the evidence in each handoff, not on the completion message.
• Approve gated actions (publish, send, buy, deploy, delete, grant access) explicitly, one at a time.
• Without sub-agent support, the model plays each role in turn.
• See a filled-in version: consolidating the Chopper Unity repos.

From concept art to a Unity character

This guide turns concept images into a game-ready Unity asset, using the low-poly Viking lumberjack "Chopper" as the running example. The concepts are visual reference, not a finished model. Build the final asset by hand in Blender, then export it to Unity. See the worked example for the manager prompt filled in for this job.

Concept references

Recommended pipeline

1. Concept images
2. Blender blockout
3. Low-poly production mesh
4. UVs and stylized textures or materials
5. Rig and skin weights
6. Animations
7. FBX export
8. Unity prefab, collider and Animator

For this art style, Blender plus Unity is the most straightforward path. Do not generate an FBX directly from the images. AI image-to-3D tools can help with rough blockouts, but they usually produce bad topology, messy UVs and unreliable rigs. Build the final game asset manually.

1. Turn the concept into a production brief

Decide which version is the canonical in-game character before modeling. The images suggest these variants:

Build the base Unity prefab from detachable parts, so one skeleton can swap equipment without separate characters:

Chopper
  Body
  Head
  Beard
  Hair
  Shirt
  Vest
  Belt
  Chainmail
  Boots
  Axe
  Shield
  Helmet   (disabled unless equipped)

Keep the important read

At normal gameplay distance the player should immediately see:

• A broad upper body and a large square beard.
• Strong red plaid sleeves.
• A large axe silhouette.
• Brown leather armor and belt, and dark boots.
• An optional shield as a readable defender variant.

Do not model tiny stitches, chain links or engraved details as geometry. Put them in textures, simple planes or normal maps. In a blocky game character, silhouette matters more than micro-detail.

2. Set up Blender correctly

Use the images as reference, but do not trace them as orthographic blueprints. Proportions and camera perspective change between images.

1. Install Blender and create a new file.
2. Press Shift + A, then Image, then Reference.
3. Add the front-facing neutral image first (concept-3 for the base body, concept-1.5 for the equipment).
4. Add the forest scene separately, only for style and mood.
5. Put the references in a collection named Reference, and lock or hide it once modeling starts.

Use real scale from the start. Treat 1 Blender unit as 1 meter and apply transforms before export:

Character total height: 1.8 m
Axe: roughly 1.1 to 1.3 m
Shield: roughly chest to knee height

Organize the scene and name objects consistently, to avoid a mess once materials, animations and prefabs exist:

Chopper_Character
  REF_Concept
  GEO_Body
  GEO_Clothing
  GEO_Equipment
  RIG_Armature
  COL_CollidersPreview
  EXPORT

chopper_body, chopper_head, chopper_beard, chopper_shirt,
chopper_vest, chopper_belt, chopper_axe, chopper_shield, chopper_helmet

3. Model it as a low-poly game character

Start with a blockout, not detail. Work in this order:

1. Torso: a cube, widened at the shoulders.
2. Pelvis and legs: separate boxy forms.
3. Boots: chunky cubes with a slight forward toe.
4. Upper and lower arms: rectangular or low-sided cylinders.
5. Hands: simple mitten-like mesh, no fingers at first.
6. Head: a cube with minimal beveling.
7. Beard: several chunky planes or cubes, or a low-poly extruded mass.
8. Hair: separate blocky clumps.
9. Armor: separate vest, belt, bracers and chainmail flap.
10. Axe and shield: separate props, not joined to the body mesh.

To match the references, use flat shading, a small bevel on hard edges where needed, and no dense subdivisions. Build large shapes from boxes, low-sided cylinders and simple extrusions. Leave plaid, sewing, leather grain, metal scratches and chainmail to the texture.

Triangle targets

These are starting points, not hard limits.

A modern PC game can go higher, but this range performs well and is plenty for the stylized look.

Build the axe separately

The axe is a key recognition feature, so make it modular, using the turnaround in concept-1.7 as the guide:

axe_handle
axe_head
axe_grip_wrap
axe_ornament

Parent the finished axe to a hand socket or hand bone. That makes it easy to replace later with a two-handed axe, a hammer or different axe tiers.

Build the shield separately

The shield is its own mesh with a low-poly wooden body, a metal rim, a central boss, the axe emblem or painted symbol, and optional rear straps. Attach it to the off-hand bone. If it should sit on the back while unequipped, use another socket such as Shield_Back.

4. UVs, textures and materials

Once the silhouette works, make the asset game-ready.

1. Apply object scale in Blender: Ctrl + A, then Scale.
2. Mark seams in hidden areas: inside legs, under arms, the back of the vest, the bottom and back of beard chunks, and the shield rim and back.
3. Unwrap with U, then Unwrap.
4. Pack UV islands with enough padding.
5. Use a single atlas where practical.

Chopper_Character_Albedo.png   2048 x 2048
Chopper_Character_Normal.png   optional
Chopper_Character_Mask.png     optional

For a more retro, blocky look, a 1024 x 1024 atlas can be enough. Keep the material count small:

M_Chopper_BodyClothes
M_Chopper_Metal
M_Chopper_Weapon
M_Chopper_Shield

Or use one atlas and material for almost everything, for easier batching. Start with Unity's Lit shader:

• Base Map: plaid, leather, wood and metal color.
• Metallic: high for the axe blade and shield rim, low for leather, cloth and wood.
• Smoothness: low for cloth and wood, moderate for worn metal.
• Normal map: optional, useful for subtle leather and chainmail detail.

The red plaid shirt is texture work. Do not model the checkered pattern.

5. Rig it for Unity

Make one armature with a standard humanoid hierarchy:

Root
  Hips
    Spine
      Chest
        Neck
          Head
        LeftUpperArm
          LeftLowerArm
            LeftHand
        RightUpperArm
          RightLowerArm
            RightHand
    LeftUpperLeg
      LeftLowerLeg
        LeftFoot
    RightUpperLeg
      RightLowerLeg
        RightFoot

Useful extra bones:

Weapon_R      parented to RightHand
Shield_L      parented to LeftHand
Shield_Back   parented to Spine or Chest
Beard_01 to 03   only if you need beard movement
Cape or strap bones, if applicable

For this rigid, blocky model, use fairly firm weighting. Elbows, knees, shoulders and hips need the most testing. The beard, bracers, boots, axe, shield, helmet and chainmail can often be weighted rigidly to one or two bones.

Rig in a clean T-pose or A-pose. An A-pose suits the wide-shouldered character: arms angled down about 30 to 45 degrees, feet slightly apart, facing forward, and no dramatic weapon pose in the exported bind pose.

Unity's Humanoid rig expects a recognizable two-arm, two-leg, head skeleton and maps your bones to an Avatar. Check that mapping manually after import, especially hands, limbs, spine and head. See the Unity Avatar documentation.

6. Make the essential animations

For an initial playable character, create only what you need:

Idle
Walk
Run
Attack_1
Attack_2
HitReact
Death
Block         optional, shield variant
EquipShield   optional

• Idle: 1 to 2 seconds, looped.
• Walk and Run: looped.
• Axe attack: about 0.7 to 1.0 seconds.
• Hit reaction: roughly 0.25 to 0.5 seconds.
• Death: one non-looping animation.

Keep the axe on the right-hand bone and the shield on the left-hand bone during animation. Later, use animation events to define the damage frame of the axe swing.

First gameplay test

Do this before spending time on elaborate textures:

1. Put the basic modeled character into Unity.
2. Rig and import it.
3. Create an idle and a walk.
4. Test with a capsule collider and a controller.
5. Confirm feet, axe position, shield clipping and camera distance.
6. Only then refine materials, beard shapes, chainmail and helmet.

This catches scale, skeleton and animation problems while they are cheap to fix.

7. Export from Blender to Unity

1. Put the character at the world origin.
2. Make sure it faces your chosen forward direction consistently.
3. Apply rotation and scale: Ctrl + A, then Rotation and Scale.
4. Delete or hide the reference images.
5. Check that the mesh, armature, materials and animations are named cleanly.
6. Export as FBX.

Typical Blender FBX settings:

Selected Objects: enabled
Object Types: Mesh, Armature
Apply Transform: enabled
Add Leaf Bones: disabled
Bake Animation: enabled, if exporting animation
Path Mode: Copy (embed textures only if you intend to)

A clean Unity folder structure:

Assets/
  Game/
    Characters/
      Chopper/
        Models/        chopper.fbx
        Textures/
        Materials/
        Animations/
        Prefabs/       Chopper.prefab
        Scripts/

Unity exposes separate model, rig, animation and material controls in the Inspector. See the Unity model import documentation.

8. Configure the model in Unity

Select chopper.fbx in the Project window.

Model tab

• Scale Factor: verify the character is the expected height.
• Normals: import them if you authored them, otherwise calculate if needed.
• Read/Write Enabled: leave off unless a runtime system requires it.
• Mesh Compression: test visually before enabling aggressively.

Rig tab

Animation Type: Humanoid
Avatar Definition: Create From This Model

Click Configure and verify the bone mapping.

Materials tab

Choose between using the materials embedded in the FBX or extracting them into the project. For a maintainable project, extract materials into Assets/Game/Characters/Chopper/Materials/ and assign textures there.

Make the prefab

Chopper.prefab
  Animator
  CharacterController or CapsuleCollider
  Your movement and combat script
  Mesh hierarchy
  Weapon socket
  Shield socket

For a third-person playable character, also add a CharacterController (or a CapsuleCollider plus Rigidbody), a simple Animator Controller with Idle, Walk, Run and Attack states, and a camera-follow target on the chest or upper spine.

Milestones

Do not aim for the polished forest scene first. Aim for this:

• Week 1: gray-box Chopper model, axe and shield modeled, clean humanoid rig, FBX imports into Unity, idle and walk work in a test scene.
• Week 2: plaid, leather and metal texture atlas, attack, block, hit and death animations, prefab, collider and Animator Controller, equipment swaps for helmet and shield.
• Week 3: polish proportions and materials, add VFX, sound and LODs.

Applying it to your exact concept

Use concept-1.5 as the canonical character sheet, because it shows the helmet, axe, shield and full body on a neutral background. Use concept-3 for the exposed-head version, concept-1.8 for the Elite armor upgrade (steel shoulder plates and a plated vest), concept-1.7 for the axe, and concept-1 only for environment and mood. Make the character from these detachable modules:

Base body
Beard / hair
Red plaid shirt
Leather vest
Belt + pouch
Chainmail flap
Bracers
Boots
Axe
Shield
Helmet

That gives one character with easy variants:

Chopper_Worker    no helmet, no shield
Chopper_Warrior   helmet + axe + shield
Chopper_Elite     upgraded armor and materials
Chopper_Enemy     recolored shirt, different axe