The pixel-art rulebook

Core principles

Pixel art is not "a small image". It is an image where every pixel was a decision. That constraint is the whole medium: an agent that treats a 32×32 canvas as a low-resolution render will produce something that is technically correct and unmistakably wrong.

Palette and colour

Shading and light

Silhouette and form

Outlines and edges

Animation

Layers and rigging

Review checklist

Run this before telling anyone a sprite is finished. validate covers the mechanical half; the rest needs you to actually look.

Lines and curves

A pixel line is a staircase, and the eye reads its rhythm before the shape. One run shorter or longer than its neighbours shows at 1× as a bump (a "jaggy"); a 2×2 lump on a 1 px line shows as a blob. Every colour boundary is a line too, so this covers outlines, shading edges and outline-free art. Outline style is rules://04-outlines-and-edges; this file is about the pixels.

Clusters and noise

A sprite is read as shapes of colour, not as pixels. Speckle, orphan pixels, fat 2×2 clumps and parallel bands all add information nobody asked for, and at 1× the viewer reads them as dirt or as a ruler laid along the outline. Without this file an agent shades by "darker near the edge" and sprinkles detail dots; both are generated-art tells.

Anti-aliasing

Manual anti-aliasing (AA) puts a pixel of in-between colour where a step turns, so a curve looks smoother at 1×. Too little leaves a curve jagged; too much turns it into a blur, a halo on the wrong background, or a second thick line. This file decides whether, where and how much. Filters, resampling and soft brushes are not AA.

Dithering and texture

Dithering fakes a colour you do not have by mixing two you do; texture suggests a material. Both add pixels that are not silhouette or light, so at small sizes they read as noise, and in animation they flicker. Without this file an agent reaches for noise dither or a smooth gradient tool and produces grain, wobble, or plastic.

Readability and scale

Readability is how fast a stranger understands what you pixelled, at the size it will be seen. Art that looks heroic at 800% can vanish in the build; detail the scale cannot hold becomes blobs, and more pixels never fix a shape problem. This file is the test battery and the detail budget; silhouette design is rules://03-silhouette-and-form.

Colour for pixel art

Colour is where machine-made pixel art gives itself away: ramps that only get darker, one saturation for every swatch, pure black outlines, a rainbow where three hues would do. This file fixes ramp structure, hue travel, saturation and value in numbers. Palette size and hardware limits live in rules://21-limited-and-platform-palettes; per-material ramps in rules://22-materials-hard and rules://23-materials-soft; coloured light in rules://24-lighting-scenarios.

Limited and platform palettes

A palette limit is a design tool, not a handicap: it forces harmony and fast decisions. But "retro" without the real limits is just a costume — a NES sprite with eight colours, a Game Boy sprite with a fifth shade. This file gives the numbers per platform, the budget per sprite size, how to cut a palette without losing the read, and ready-to-load hex lists. Era style (outlines, dither habits, tile conventions) is in rules://90-platform-styles; ramp theory in rules://20-color-for-pixel-art.

Hard materials: metal, gold, glass, gems, stone, wood, bone

Hard materials fail in two ways: everything gets the same grey-brown ramp, or every material gets a highlight. A material is mostly its highlight behaviour and ramp contrast — how many pixels shine, how hard the band edges are — not a special colour. Soft materials are in rules://23-materials-soft; light colour in rules://24-lighting-scenarios; ramp theory in rules://20-color-for-pixel-art.

Soft materials: cloth, skin, hair, fur, leather, scales, slime

Soft materials fail by being drawn like metal: sharp bands, a highlight on everything, texture as noise. They shade gradually, shine little or not at all, and are told mostly by their edge and by where the darks sit. Hard materials are in rules://22-materials-hard; hair and clothing shapes in rules://35-hair-and-clothing; faces in rules://32-heads-and-faces; ramp numbers in rules://20-color-for-pixel-art.

Lighting scenarios

Without a stated light, pixel art shades every form from its own outline inward: concentric bands, pillow shading, shadows that are just "darker". This file fixes the vocabulary of a lit form, then gives numbers for the common set-ups — sun, overcast, window, fire, night, rim, back-light, two sources, light from below — and the shadow rules that go with them. General ramp theory is in rules://20-color-for-pixel-art, the basic shading order in rules://02-shading-and-light, flame and glow effects in rules://80-vfx-fire-smoke-magic.

Proportions by size

Head count is the first decision in a figure and the one most often made by accident. Seven heads on a 16 px canvas leaves a 2 px head with no face; two heads on a 64 px canvas reads as a toy even when the brief says "veteran". Heads-tall carries age and tone, and the canvas decides how many of them you can afford.

Anatomy and pose

A sprite with head, chest and hips stacked on one vertical and both arms hanging parallel reads as a mannequin, however well it is shaded. At 16–32 px the pose is nearly the only thing the player reads, and the pose comes from three things: a line of action, where the weight sits, and which way the ribcage and pelvis tilt against each other. Anatomy detail is the last 10 %; it only matters up to the few landmarks that survive at your size.

Heads and faces

Heads fail at sprite scale in three ways: features on the wrong lines (eyes too high, mouth glued to the chin), a flat front-on mask where a turned head was wanted, and features drawn before the shape that holds them. This file fixes the geometry — where each feature sits at 8, 12, 16, 24 and 32 px in front, 3/4 and side view. Eyes, brows and emotion: rules://33-eyes-and-expressions. Bust portraits from 48 px: rules://38-portraits. Head size against the body: rules://30-proportions-by-size.

Eyes and expressions

At sprite scale a face is 20–60 pixels and emotion lives in three channels — eye openness, brow slope, mouth shape — each 1–3 px. One pixel the wrong way and surprise reads as anger, or the face reads as nothing. This file gives the eye ladder per head size, gaze, blinks, mouth shapes and seven expressions at 16 and 32 px heads. Where features sit on the head: rules://32-heads-and-faces. Bust portraits: rules://38-portraits. Idle and blink timing: rules://41-idle-and-breathing, rules://40-timing-and-spacing.

Hands and feet

At 32 px a hand is a dozen pixels and a boot a dozen more, yet they decide whether a figure grips, points, stands or floats. Without a size ladder an agent draws five-pixel fingers on a 16 px sprite (noise) or a featureless blob that gestures nothing (mush); without a foot rule the sprite hovers, skates or changes shoe size between frames. This file is the ladder: what a hand and a foot are at each size, in each view, with the pose templates to copy. Proportions are rules://30-proportions-by-size; the walk itself is rules://42-walk-and-run.

Hair and clothing

Hair is the identity of a 16 px character and the largest shape on a 32 px head; cloth is the part most likely to turn into noise. Without mass rules, hair becomes scattered strand pixels or a plain helmet; without fold rules, cloth becomes wrinkles on a tube, or a flat colour with no weight; capes become rectangles. This file gives the mass shapes, the fold types, the cloth-versus-armour split and the cape shapes, with templates. How they move is rules://45-secondary-motion; materials and colour are rules://23-materials-soft, rules://22-materials-hard and rules://20-color-for-pixel-art.

Character design

A character that is only a correct figure is a mannequin in a costume. At 16–32 px identity comes from three things the viewer takes in before any face: the silhouette, how the head / torso / legs masses compare, and one or two strong elements. Decide those first; detail only decorates what the shape already says, and a generic outline cannot be rescued by shading.

Views and directions

Most direction failures are consistency failures: a head that grows between facings, a face drawn on the back of a skull, a sword hand that jumps sides when the sprite is mirrored, light that flips with it. A direction set is one character seen from several sides on a shared set of rows, not four separate drawings. Decide the set, fix the rows, then draw.

Portraits

A portrait is a face at 32–64+ px shown in a dialogue box, a select screen or a status panel, usually held for seconds. It must carry identity (face shape, hair, one defining feature) and emotion (a swappable brow/eye/mouth set) and still read at 1×. Without rules agents draw a sprite head made big: 2×2 eyes, no planes, hair as a helmet. Head geometry: rules://32-heads-and-faces; eyes, mouths and expression recipes: rules://33-eyes-and-expressions.

Timing and spacing

A sprite has 4–12 drawings, so when each one shows and how far apart they sit does more than any single drawing. Equal durations and even spacing read as a slideshow of good poses; the same poses with held extremes and eased gaps read as weight. This file maps the twelve principles onto pixels and milliseconds and holds the shared tables. Cycles live in rules://42-walk-and-run, rules://41-idle-and-breathing, rules://43-jump-fall-land.

Idle and breathing

An idle frame held still reads as a corpse; an idle drawn by shifting the whole sprite 1 px reads as a lift. What sells "alive" is small, lagging, feet-planted motion that loops without a seam and never changes the character's size. This file is the recipe, with the frames to copy. Timing vocabulary lives in rules://40-timing-and-spacing.

Walk and run

A walk that skips the pass pose reads as sliding; a run with no airborne frame reads as a fast walk; a cycle whose foot speed does not match the engine's ground speed skates. Without per-frame numbers an agent draws "legs apart, legs together" and every character ends up with the same limp. This file gives the poses, the pixel offsets per frame, the timings and the checks for side-view humanoids. Quadrupeds are rules://51-animal-gaits; top-down is rules://47-top-down-animation; timing theory is rules://40-timing-and-spacing.

Jump, fall and land

A jump is a position curve plus three squashes. Without the curve the character floats; without the squashes there is no weight; without a fall pose the player cannot read which way they are moving. The poses below are 16 px side views facing right; mirror for left. Easing and frame-rate vocabulary: rules://40-timing-and-spacing.

Attacks and impacts

An attack with no wind-up is a pose swap, one with no recovery is a pogo stick, and a hit with no hold is a wave through air. The weight of a blow comes from three things the drawings only imply: the opposite-direction preparation, the one fast smeared frame, and the pause when it lands. This file covers melee and body attacks, hit reactions, death and block, side view; top-down variants are in rules://47-top-down-animation, flashes and screen shake in rules://81-impacts-and-game-feel.

Secondary motion

A sprite whose hair, cape and weapon move in lock-step with the body reads as a cut-out. A sprite whose loose parts flap at random reads as broken. Secondary motion is the middle path: every loose part is attached to something, starts later than it, travels further at its free end, overshoots when the body stops, and settles. This file is for hair, capes, scarves, tails, loose cloth, flags, carried items and weapon tips. Primary cycles are rules://42-walk-and-run and rules://44-attacks-and-impacts; motion below one pixel is rules://46-subpixel-animation; wind particles are rules://82-particles-and-weather.

Sub-pixel animation

Pixels do not move by halves, so slow motion either jumps a full pixel (a stutter) or sits still. Sub-pixel animation moves tone instead: the neighbour that gains value and the neighbour that loses it make the eye read a shift smaller than one pixel. It is the only way to ease a 1 px move, keep an idle alive, or wobble something without changing its silhouette. Done everywhere, it melts the sprite. Stills use the same trick: rules://12-anti-aliasing.

Top-down animation

Top-down sprites fail in predictable ways: the back view has a face, the sprite bobs when the player turns, the diagonal is a rotated side view, every walk doubles the frame count, and a flipped sprite holds its sword in the wrong hand. The cure is a direction budget decided up front, one shared canvas and foot row, and a short list of per-frame offsets. This file covers 3/4 top-down (RPG, action-adventure) walk, run and idle in 4 and 8 directions. Direction theory and proportions are rules://37-views-and-directions and rules://30-proportions-by-size; side-view walks are rules://42-walk-and-run; attacks are rules://44-attacks-and-impacts (a top-down sword strike is topdown-e-attack below).

Quadrupeds

Four legs bolted under a blob read as a table. A dog, a horse and a cow drawn from one body plan read as the same animal in three costumes. A hind leg drawn as a straight pole reads as a toy. This file gives the construction (three masses, four chains), the per-species proportions and joint heights, and side-view templates for horse, dog, cat, deer and cow. Movement is rules://51-animal-gaits; fur and coat texture is rules://23-materials-soft; the silhouette test itself is rules://03-silhouette-and-form.

Animal gaits

A quadruped walk drawn as "two humans glued together" slides, rows, or moves its legs in an order no animal uses. Each gait has its own footfall order and its own flight phase; get those wrong and the sprite reads as drunk, as a table on wheels, or as a human in a costume. This file gives the four-beat walk, the trot, the canter and the gallop as frame tables and key poses, with joint behaviour, bob, timing and looping. Anatomy and proportions are rules://50-quadrupeds; the two-legged version is rules://42-walk-and-run; general timing is rules://40-timing-and-spacing.

Birds and flight

A bird drawn as a mammal with a beak has a knee in the wrong place and a wing that is a flat paddle. A flap cycle built by tilting one rigid blade up and down looks like a windmill. This file gives the body plan, the one visible leg joint that people draw backwards, wing structure for birds and bats, the four-frame flap with body bob and timing, and the small cases (hover, glide, perch). Quadruped anatomy is rules://50-quadrupeds; follow-through in general is rules://45-secondary-motion; sub-pixel hover is rules://46-subpixel-animation.

Small creatures

Fish, bugs, frogs and snakes get drawn as miniature mammals: a fish with a head and shoulders, an insect with four legs and a face, a snake as a stiff tube. Each group has a short list of parts that must be present and a movement that is unlike a mammal's. This file gives part counts, proportions and templates for fish, insects and spiders, frogs and snakes, and the cheapest animation that sells each. Blob monsters (slimes) and big creatures are rules://54-monster-design; wings are rules://52-birds-and-flight; quadrupeds are rules://50-quadrupeds.

Monster design

A generated monster is usually a pile of scary parts: four animals' worth of horns, claws, eyes and teeth on a body with no shape. It reads as noise at 1×, and no two of them look different in silhouette. This file gives a way to decide what the creature is, shape language that makes it read in one glance, a build order (silhouette → colour blocks → finish), slime, undead and dragon rules, size by game role, and templates for each. General character silhouette is rules://36-character-design; animal anatomy is rules://50-quadrupeds; small animals are rules://53-small-creatures.

Skies and atmosphere

A sky drawn as one flat blue fill with white blobs kills the scene's depth, and a cloud drawn as a grey-shaded outlined cotton ball reads as clip-art. The same mistake repeats at every distance: far layers painted with near-layer contrast, so the world looks like a collage. Sky, clouds, time of day and the distance rules that every background layer obeys live here. Mountains are in rules://61-landscapes-and-terrain, layer scrolling in rules://62-parallax-backgrounds.

Landscapes and terrain

A landscape drawn as texture first, with no plan for planes, collapses into one muddy mass: mountains, trees and ground fuse, the player's lane is as busy as the scenery, and every ridge is a symmetrical triangle. This file is the placement and shape of the big masses (sky line, ranges, hills, ground bands, cliffs, dunes). Colour-with-distance is rules://60-skies-and-atmosphere, scrolling is rules://62-parallax-backgrounds, trees and water have their own files.

Parallax backgrounds

Parallax layers fail in motion, not in the still: a seam that pops when the strip wraps, a layer that hovers because its bottom is transparent, a sun that repeats every screen, scroll rates that make the far hills outrun the near ones, or a layer shifted by half a pixel so the edges shimmer. This file is the authoring contract for a layer: how many, how fast, how wide, how it loops, and how it is coloured relative to its neighbours. Distance colour rules are rules://60-skies-and-atmosphere, silhouettes rules://61-landscapes-and-terrain.

Trees and foliage

A tree drawn leaf by leaf becomes noise, and a tree shaded with one smooth radial gradient becomes a pillow with a dark ring. Both read as "generated". Real foliage is a few lit volumes with ragged edges and quiet interiors, and conifers, palms and background trees each obey a different recipe. This file covers the crown, trunk and tree types; ground cover and rocks are rules://65-ground-rocks-grass, leaves in the wind rules://45-secondary-motion, falling leaves rules://82-particles-and-weather.

Water

Water drawn as a blue fill with white dashes looks like a rug. It needs three things at once: a depth gradient, a surface layer that moves less than one pixel at a time, and a reflection or shore that is cut into strips instead of mirrored whole. This file covers still water, flowing water, waterfalls, reflections and animated tiles. Particle foam and rain are rules://82-particles-and-weather; tile connection logic is rules://66-tiles-and-autotiling; ice and slime are rules://22-materials-hard and rules://23-materials-soft.

Ground, rocks and grass

Ground is most of the screen, so it is where generated scenes fail first: grass with a blade on every pixel, "dirt" in nine near-identical browns, a lone rock that becomes a visible grid the moment the tile repeats, rocks shaded like pillows. This file builds ground that stays quiet behind the characters and still reads as grass, dirt or stone. Seams, edges and autotile sets live in rules://66-tiles-and-autotiling; walls and floors made of bricks in rules://67-architecture-and-interiors.

Tiles and autotiling

A tile is drawn once and shown a thousand times, so every flaw is multiplied: a lone rock becomes wallpaper, a seam becomes a grid, an edge set without inner corners breaks on the first L-shaped patch. And an autotile set authored in the wrong order exports a wangset that picks the wrong tile everywhere. This file is the method for seamless tiles, terrain transitions and the standard autotile layouts, and what each means for the tileset tool. Ground textures: rules://65-ground-rocks-grass; brick, doors, windows: rules://67-architecture-and-interiors.

Architecture and interiors

Everybody knows what a wall, a door and a window look like, so errors show at once: bricks like plastic sheets, windows that are holes, a door the size of a shutter, a roof with no overhang or eave shadow, rooms with no wall at all. This file is how to build facades, brickwork, openings, roofs and rooms on a tile grid. Seams and edges: rules://66-tiles-and-autotiling; ground: rules://65-ground-rocks-grass; true perspective and iso: rules://70-perspective, rules://71-isometric.

Perspective and projection

Generated scenes fail at perspective one way: a 3/4 house, a front-on fence and a top-down tree share a screen, each from its own camera. Pixel games dodge true perspective on purpose. This file is how to pick one parallel projection, hold it, and where real vanishing points are still worth drawing. Isometric specifics are in rules://71-isometric, shaded forms in rules://72-3d-forms.

Isometric (2:1)

Isometric fails at the first line: a true 30° edge makes an uneven 2,3,2,3 stair and the whole scene looks hand-wobbled. Everything below follows from one fact, pixel isometric is a 2:1 dimetric grid, and from one habit, never eyeball a cube, a circle or a roof. For the choice between projections see rules://70-perspective.

3D forms: circles, spheres, cylinders, cubes

A square is a shape, a cube is a form: the difference is light. Without a decided light and a decided way each form turns, agents produce pillow shading, gradients on flat faces, and circles that are "about round". This file gives the exact circles and ellipses, and how each primitive is lit. Isometric placement is in rules://71-isometric; materials in rules://22-materials-hard.

Props and items: weapons, potions, chests, keys, shields

Props expose every error in a scene because their geometry is exact: a chest whose lid and body use two different cameras, a sword in white, a potion with no glass. Items are also read at a glance and at 1×, so silhouette and one clear material cue matter more than detail. Forms underneath: rules://72-3d-forms. Materials: rules://22-materials-hard.

Vehicles and machines

Vehicles fail on proportion before they fail on rendering: wheels too small, a body as tall as it is long, a jet that is a triangle with a dot. Shading cannot fix a wrong ratio. Decide the type, place wheels (or the main masses) first, then wrap the body, then spend your few remaining pixels on three to five details. Forms: rules://72-3d-forms; rotation sets: rules://75-rotation-and-turnarounds.

Rotation, turnarounds and pseudo-3D

Rotating pixel art with an algorithm shreds it: diamonds, skewed squares, smeared outlines, new colours. Turning a character or object means redrawing it at each angle with the same volume, height and palette, or building it from 3D on purpose. This file covers direction sets, objects that spin, and the pseudo-3D tricks (stacking, 3D render) that avoid hand redrawing. Walk/run sets in rules://42-walk-and-run and rules://47-top-down-animation; character views in rules://37-views-and-directions.

VFX: fire, smoke, explosions and magic

Effects are judged by motion alone, and agents draw them as stills: a flame with a black outline, smoke as a grey ball, an explosion as one orange frame. Each effect has a fixed layer order, colour order and frame skeleton; this file gives them. Hit timing and shake are in rules://81-impacts-and-game-feel, falling things in rules://82-particles-and-weather, light cast on the scene in rules://24-lighting-scenarios.

Impacts and game feel

A hit that is drawn correctly but feels like nothing is a missing-feedback bug: the pose changes, nothing else does. "Feel" is a small stack — one contrast frame, one smear, one spark, a freeze, a shake, a push-back — each short, and each tuned to the size of the event. This file gives the stack, the numbers that shipped games use, and which parts an agent can draw. Pose timing is in rules://44-attacks-and-impacts, effect art in rules://80-vfx-fire-smoke-magic.

Particles and weather

Particles are tiny, so every one that is wrong is wrong in public: a row of rain drops on a grid, snow that falls straight down at one speed, a pixel-noise "dust" cloud, leaves that are green squares. This file gives the layer model, the loop arithmetic that makes weather tile, and the drop/flake/leaf/dust frames. Big effects are in rules://80-vfx-fire-smoke-magic, water in rules://64-water, wind-moved foliage in rules://63-trees-and-foliage and rules://45-secondary-motion.

UI and icons

UI art fails differently from sprites: it is looked at constantly, at tiny sizes, next to text, and it must stay quiet while the character carries the feedback. Typical failures are stretched panels with smeared corners, health bars in the wrong colour language, an icon that is a miniature painting, and a set where every piece has a different light direction. This file covers frames, bars, buttons and icon design; the text inside them is in rules://84-bitmap-fonts, items as props in rules://73-props-and-items, bust portraits in rules://38-portraits.

Bitmap fonts

Text is the most precise pixel art in a game and the least forgiving: a 1 px baseline slip, a filled counter or an O that reads as 0 is visible at 1×. Agents fail by inventing glyphs on the spot, by outlining small fonts into blobs, and by asking the shipped font for characters it does not have. This file gives the metrics of the shipped font, a 3×5 font to stamp from, and the rules for spacing, contrast and titles. Text on panels is in rules://83-ui-and-icons, lettering as an effect in rules://81-impacts-and-game-feel.

Platform styles

An era look is not a filter. NES, Game Boy, SNES, Genesis and PICO-8 look the way they do because of a few hardware numbers: screen size, visible colours per sprite, tile grid and sprite-per-line limits. Without them an agent writes "8-bit" on a 40-colour smooth-shaded sprite, dithers where the hardware never would, and outlines what the era left bare. This file turns each platform into numbers and policies that palette, validate and read_pixels can check.

Composition and scenes

A scene is a decision about where the eye goes. Without it an agent renders every region at equal importance: same cluster size, same contrast, same texture, no resting place, a horizon through the middle and a hero sitting on a tangent. The result is correct pixels and no picture. Decide the focal point, the value groups and the quiet zones on a thumbnail before any colour is chosen.

Generated-art tells

Machine-made pixel art is a picture of pixel art, not pixels on a grid. Image models work in a continuous space with no notion of a hard edge, a fixed palette or a grid, so their output has soft blocks of uneven size, hundreds of near-identical colours, speckle used as texture, shading that follows the outline, and the same density everywhere. Naive downscaling of a large drawing produces a second family: mush, lost features, extra colours. An agent that draws natively at 1× cannot make mixels, but every route by which foreign or filtered pixels enter its canvas can reintroduce a tell. This file is the catalogue, how to detect each with look, validate, palette and read_pixels, and how to fix it.

Take any Aseprite request end to end

The front door for any Aseprite or pixel-art request. Works out what the user actually wants, picks which workflows to run and in what order — and whether to work in the user's open Aseprite window or a headless batch Aseprite (`--headless` / `--live` force it) — hands parts to the specialist agents where the harness has them, and does not stop until the result has been looked at and reviewed. Use when a request spans several steps ("make me an animated knight for Godot") or when you are unsure which workflow applies.

Plan a sprite before drawing it

Turn a vague pixel-art request into a written brief — size, palette, view, light, outline style — and confirm it with the user before any pixel is drawn. Use when the request is open-ended ("make me a knight") rather than a specific edit.

Design it first — concept sheet and storyboard

Before drawing a new character, prop, scene or animation, write an art spec, turn it into a ready-to-paste prompt for an image-generation model, and offer the user a choice — generate a concept sheet or storyboard with it and send it back, or continue without one. When reference art arrives (from that prompt or from the user), read it into a PixelSpec and import it panel by panel, so the pixel work reproduces a decided design instead of improvising one. Use after the brief for anything drawn from scratch, and whenever the user supplies reference art; skip for edits to existing art.

Create a sprite document

Create a new Aseprite document with the right canvas size, colour mode, palette and layer structure, so later work does not have to fight the setup. Use when starting fresh rather than editing an existing sprite.

Choose, build and repair a palette

Pick a palette that fits the request, build hue-shifted ramps, or clean up a sprite whose colours have sprawled. Use when the user asks about colour, wants a specific retro look, or when validate reports off-palette colours.

Draw a sprite

Draw a sprite from silhouette to finished pixels, in the order that catches mistakes while they are still cheap — block in, check the silhouette, shade, outline, verify. Use for the main body of any drawing task.

Shade a sprite

Add light and shadow with proper hue shifting, one step at a time, so the sprite gains form without gaining the flat-luminance look that marks generated pixel art. Use when flat art needs volume.

Rig a character for animation

Split a character onto named layers — head, torso, arms, legs — so it can be animated by moving cels instead of redrawing pixels. Use before animating anything, or when limbs are baked into one layer.

Animate a cycle

Build an idle, walk, run or attack cycle from key poses, set timing that reads as motion rather than a metronome, tag it, and review it as a filmstrip. Use when a rigged sprite needs to move.

Build a tileset

Design seamless tiles and autotile sets, or deduplicate a hand-painted mockup into a reusable tileset, then export for Tiled or Godot. Use for level art, terrain and anything that repeats.

Review a sprite before calling it done

Run the mechanical checks and the by-eye checks, then report what you found with evidence instead of declaring success. Use before finishing any pixel-art task, and when the user asks "is this good" or "why does this look off".

Fix or iterate on existing art

Change a sprite that already exists — the user's own work or your earlier output — without destroying what is already right. Use for edits, touch-ups, style corrections and "make it more X" requests.

Export game-ready assets

Produce the files an engine actually consumes — spritesheets with atlases, GIFs, scaled PNGs — with the tags and layout the target needs. Use when work is finished and needs to leave Aseprite.

Submit a finished sprite to the community gallery

Turn the sprite you just made into a gallery pull request against with-pebbly/aseprite-ai-artist — exported files, an honest generation.yaml (prompts verbatim, model, plugin version, validate results, optional benchmark scoring), checked with `pnpm gallery:check`, opened with the gh CLI. Use when the user wants to share, publish or submit their work to the gallery or the benchmark.