Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust

A third agent skill: klad skill pixel, the craft of pixel art

Indicode BVf7c8e986099a
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6fa699f..f4e10f7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
The first builds, and klad's licences.
- A new icon, painted in klad: a K in two brush strokes.
+- A third agent skill, `klad skill pixel`: the craft of pixel art (size and palette, silhouette, clusters, clean lines, outlines, ramps with hue shift, shading without pillow shading or banding, anti-aliasing by hand, tiles, animation, and a checklist at real size). Under the MIT licence, like the other two.
- Pixel checks. `klad check sprite.klad` lists the usual slips of pixel art with their places: single stray pixels, doubled corners in one-pixel lines, jagged lines, banding, and colours that are not in the palette. In the editor **Check the pixels** marks them on the canvas and follows your edits until you turn it off. They are places to look at, not errors.
- Tilesets. **View > Tileset: cut into tiles…** cuts a drawing into tiles of one size; the canvas shows the tile lines, and **as a tile set** in the export window writes a Godot TileSet with a tile for every cell that is not empty. From the command line: `klad new ground.klad --pixel 64x48 --tile 16`, `klad canvas --tile 16`, `klad pixels --tile 2,0` and `klad pixel --grid --tile 2,0` to read and draw one tile at a time, and `klad export --tileset <folder>`.
- Pictures to pixels. **File > Pixels of a picture…** turns a PNG or JPEG into pixels on the pixel layer you are on, in the palette's colours, or makes a pixel drawing of the layer you are on or of the whole picture at a size you choose. From the command line: `klad pixelize sprite.klad --image ref.png --to l1`, `klad pixelize hero.klad --size 64`, and `klad import ref.png` for a new pixel drawing from a picture. Each pixel becomes part of a mark bound to a palette colour, so the result is edited like any pixel drawing.
diff --git a/README.md b/README.md
index 8a58325..48c37bb 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ An image generator hands you pixels, and the only edit left is another roll of t
3. **Point.** Pin a note on the canvas or select the part you mean ("more moss on this side"). The agent reads both.
4. **Take over.** Repaint whatever you like by hand, the agent's strokes as much as your own. Its strokes are marked as its own and every change is one step in a shared history, so you can undo any of it.
-The prompt to start with is under [Try it](#try-it). `klad skill` prints the agent skill in `docs/skill/SKILL.md`: how to look at a drawing, change it and check the result. A second one, `klad skill drawing` (`docs/skill/drawing/SKILL.md`), teaches the craft: planning a picture, light on form, values, edges, colour, materials and how to judge the result. Both are MIT, so use them with any agent and any tool. Open the drawing to watch and draw along:
+The prompt to start with is under [Try it](#try-it). `klad skill` prints the agent skill in `docs/skill/SKILL.md`: how to look at a drawing, change it and check the result. A second one, `klad skill drawing` (`docs/skill/drawing/SKILL.md`), teaches the craft: planning a picture, light on form, values, edges, colour, materials and how to judge the result. A third, `klad skill pixel` (`docs/skill/pixel/SKILL.md`), does the same for pixel art. All are MIT, so use them with any agent and any tool. Open the drawing to watch and draw along:
What an agent paints depends on the agent and on how much you steer it. The skills teach it the tool and some craft; the pen in your hand does the rest.
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
index 65d57c2..1cd58af 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -2321,7 +2321,7 @@ enum Command {
},
#[command(
about = "Print an agent skill: how an agent draws with klad, or the craft of drawing itself",
- long_about = "Print an agent skill, to hand to an agent as its instructions.\n\n klad skill how an agent draws with klad: the commands, layers, brushes and traps (docs/skill/SKILL.md)\n klad skill drawing the craft: planning a picture, light on form, values, edges, colour, materials, line, a painting method and a critique checklist (docs/skill/drawing/SKILL.md)\n\nBoth are under the MIT licence."
+ long_about = "Print an agent skill, to hand to an agent as its instructions.\n\n klad skill how an agent draws with klad: the commands, layers, brushes and traps (docs/skill/SKILL.md)\n klad skill drawing the craft: planning a picture, light on form, values, edges, colour, materials, line, a painting method and a critique checklist (docs/skill/drawing/SKILL.md)\n klad skill pixel the craft of pixel art: size and palette, silhouette, clusters, clean lines, outlines, ramps with hue shift, shading without pillows or banding, anti-aliasing by hand, tiles, animation and a checklist at real size (docs/skill/pixel/SKILL.md)\n\nAll three are under the MIT licence."
)]
Skill {
#[arg(help = "Which skill: klad (the default) or drawing")]
@@ -4557,8 +4557,9 @@ fn run() -> Result<()> {
Command::Skill { which } => match which.as_deref() {
None | Some("klad") => print!("{}", include_str!("../../../docs/skill/SKILL.md")),
Some("drawing") => print!("{}", include_str!("../../../docs/skill/drawing/SKILL.md")),
+ Some("pixel") => print!("{}", include_str!("../../../docs/skill/pixel/SKILL.md")),
Some(other) => bail!(
- "there is no skill named {other}: klad skill prints the klad skill, klad skill drawing the craft of drawing"
+ "there is no skill named {other}: klad skill prints the klad skill, klad skill drawing the craft of drawing, klad skill pixel the craft of pixel art"
),
},
Command::Samples { copy, into, json } => samples(copy.as_deref(), into, json)?,
diff --git a/crates/cli/tests/binary.rs b/crates/cli/tests/binary.rs
index 463a37d..92824a5 100644
--- a/crates/cli/tests/binary.rs
+++ b/crates/cli/tests/binary.rs
@@ -11,7 +11,7 @@ fn the_binary_runs() {
}
#[test]
-fn skill_prints_the_klad_skill_and_the_drawing_skill() {
+fn skill_prints_the_klad_skill_and_the_drawing_and_pixel_skills() {
let skill = |args: &[&str]| {
Command::new(env!("CARGO_BIN_EXE_klad"))
.arg("skill")
@@ -25,6 +25,46 @@ fn skill_prints_the_klad_skill_and_the_drawing_skill() {
let drawing = said(&["drawing"]);
assert!(drawing.starts_with("---\nname: klad-drawing\n"));
assert!(drawing.contains("## The order of work"));
+ let pixel = said(&["pixel"]);
+ assert!(pixel.starts_with("---\nname: klad-pixel\n"));
+ assert!(pixel.contains("## Clusters") && pixel.contains("## Before you show it"));
+ assert!(said(&[]).contains("klad skill pixel"), "the klad skill points to it");
+ let reference = String::from_utf8_lossy(
+ &Command::new(env!("CARGO_BIN_EXE_klad"))
+ .arg("reference")
+ .output()
+ .unwrap()
+ .stdout,
+ )
+ .to_string();
+ let words = |text: &str, lead: &str| -> std::collections::BTreeSet<String> {
+ text.match_indices(lead)
+ .map(|(at, _)| {
+ text[at + lead.len()..]
+ .chars()
+ .take_while(|c| c.is_ascii_lowercase() || *c == '-')
+ .collect::<String>()
+ })
+ .filter(|word| word.starts_with(|c: char| c.is_ascii_lowercase()))
+ .map(|word| word.trim_end_matches('-').to_string())
+ .collect()
+ };
+ let commands = words(&pixel, "`klad ");
+ assert!(commands.len() >= 8, "{commands:?}");
+ commands.iter().for_each(|command| {
+ assert!(
+ reference.contains(&format!("## klad {command}")) || reference.contains(&format!("klad {command} ")),
+ "the pixel skill names klad {command}, which klad does not have"
+ );
+ });
+ let flags = words(&pixel, "--");
+ assert!(flags.len() >= 12, "{flags:?}");
+ flags.iter().for_each(|flag| {
+ assert!(
+ reference.contains(&format!("--{flag}")),
+ "the pixel skill names --{flag}, which no command has"
+ );
+ });
let unknown = skill(&["painting"]);
assert!(!unknown.status.success());
assert!(String::from_utf8_lossy(&unknown.stderr).contains("no skill named painting"));
diff --git a/docs/DESIGN.md b/docs/DESIGN.md
index 4e25df5..66e8b51 100644
--- a/docs/DESIGN.md
+++ b/docs/DESIGN.md
@@ -1,4 +1,4 @@
-_Last updated: 2026-11-12 21:30_
+_Last updated: 2026-11-12 23:00_
# klad: design
@@ -434,7 +434,7 @@ An error is one line on stderr (`error: reading a.klad/doc.json: No such file or
| `klad export <bundle> --godot-scene [dir]`, `--godot-rig [dir]` | a Godot parallax scene; a Godot rig with its animations |
| `klad paintover <bundle> <layer> [--from] [--in] [--sizes 32,16,8] [--threshold 6] [--length 1,8] [--curve 0.5] [--brush oil] [--focus] [--vary] [--like <cel> [--frames a-b]] [--part] [--seed]` | brushwork from what is below the layer (see Paint over) |
| `klad compare <drawing\|png> <reference> [--frame] [--region name=x,y,w,h]... [--heat out.png] [--json]` | values, saturation, texture, edges and colour against a reference, in numbers and words |
-| `klad install [--dir]`, `klad skill [drawing]` | put `klad` on the terminal's path; print the agent skill, or with `drawing` the skill that teaches the craft of drawing (`docs/skill/drawing/SKILL.md`, MIT like the first, written for any agent and any tool) |
+| `klad install [--dir]`, `klad skill [drawing \| pixel]` | put `klad` on the terminal's path; print the agent skill, or with `drawing` the skill that teaches the craft of drawing (`docs/skill/drawing/SKILL.md`), or with `pixel` the craft of pixel art (`docs/skill/pixel/SKILL.md`); all MIT, the craft skills written for any agent and any tool |
| `klad samples [--json]`, `klad samples --copy <name> [--into <folder>]` | the sample drawings a build carries; copy one to draw on |
| `klad report [--drawing <bundle>]` | a problem report to paste into an issue, the drawing zipped to attach |
diff --git a/docs/cli.md b/docs/cli.md
index f84aff8..a73be76 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -4136,8 +4136,9 @@ Print an agent skill, to hand to an agent as its instructions.
klad skill how an agent draws with klad: the commands, layers, brushes and traps (docs/skill/SKILL.md)
klad skill drawing the craft: planning a picture, light on form, values, edges, colour, materials, line, a painting method and a critique checklist (docs/skill/drawing/SKILL.md)
+ klad skill pixel the craft of pixel art: size and palette, silhouette, clusters, clean lines, outlines, ramps with hue shift, shading without pillows or banding, anti-aliasing by hand, tiles, animation and a checklist at real size (docs/skill/pixel/SKILL.md)
-Both are under the MIT licence.
+All three are under the MIT licence.
Usage: klad skill [WHICH]
diff --git a/docs/skill/SKILL.md b/docs/skill/SKILL.md
index 5969a6c..56f13c0 100644
--- a/docs/skill/SKILL.md
+++ b/docs/skill/SKILL.md
@@ -8,7 +8,7 @@ description: Make and edit 2D art with the klad CLI (`klad`) in a `.klad` bundle
A `.klad` bundle is a folder: `doc.json` (layers, cels, vector nodes, palette), `strokes/<layer>/<cel>.strokes` (paint strokes and fills as data), `brushes/<id>.json` (every brush its strokes use) and `.cache/` (renders, history, notes, tiles). The `klad` CLI edits it; the user edits the same bundle in the editor (`klad open`, or the klad app). Both see each other's changes within a second. The user starts and opens drawings from the editor's start window (cmd N, cmd O, recent) and can copy a drawing's path from File (the menu bar) or the document menu at the bottom of the tool strip to hand it to you. To start one yourself: `klad new art.klad --width 1600 --height 1200 --background '#e9e4da' --sketch` (one paint layer, `l1`, and a vector layer named sketch on top, `l3`). If `klad` is not on the path, the user can run "install the klad command" from that menu (or `klad install` from the folder they unpacked); `klad skill` prints these instructions, matching the version installed. When klad itself fails (an error that starts "klad hit a bug"), tell the user and offer `klad report --drawing <bundle>`: it prints a report for an issue and zips the drawing to attach. `klad solo art.klad <layer>` hides every other layer, as an alt click on its eye does in the editor; it changes what the user sees, so use it when asked, and look at one layer alone with `klad export art.klad --layer <layer> -o one.png` instead. `klad samples` lists the sample drawings that come with klad, and `klad samples --copy lantern` copies one into the current folder to read, render or draw on: a quick way to see how a finished piece is layered.
-This skill is the tool. The craft of drawing itself (planning a picture, light on form, values, edges, colour, materials, line, a painting method and a checklist to judge the result) is a second skill: `klad skill drawing`, the text of `docs/skill/drawing/SKILL.md`. Read it before you draw or paint anything, and before you critique a picture.
+This skill is the tool. The craft of drawing itself (planning a picture, light on form, values, edges, colour, materials, line, a painting method and a checklist to judge the result) is a second skill: `klad skill drawing`, the text of `docs/skill/drawing/SKILL.md`. Read it before you draw or paint anything, and before you critique a picture. Pixel art has a craft of its own, a third skill: `klad skill pixel` (`docs/skill/pixel/SKILL.md`). Read it before you draw on a pixel layer.
Working on klad itself: the repository's `CLAUDE.md`, `CONTRIBUTING.md` and `docs/DESIGN.md` are the source of truth. Build the CLI with `just compile` (`just build` also counts the version up, for the person making a build); the binary is `target/release/klad` on macOS and `target/linux/release/klad` on Linux.
@@ -101,6 +101,8 @@ klad lasso art.klad l4 --polygon '...' --cut --rm
## Pixel art
+The commands are here. The craft (size and palette, silhouette, clusters, clean lines, outlines, ramps, shading, anti-aliasing by hand, tiles, animation) is `klad skill pixel`: read it first.
+
```
klad new sprite.klad --pixel 32x32 a pixel drawing: one pixel layer, l1
klad add art.klad layer pixel name=sprite a pixel layer in any drawing
diff --git a/docs/skill/pixel/SKILL.md b/docs/skill/pixel/SKILL.md
new file mode 100644
index 0000000..80b2987
--- /dev/null
+++ b/docs/skill/pixel/SKILL.md
@@ -0,0 +1,124 @@
+---
+name: klad-pixel
+license: MIT (LICENSE-MIT in the klad repository)
+description: The craft of pixel art, for an agent that draws sprites, tiles and small animations. How to choose a size and a palette, how to build a sprite from its silhouette, how to keep lines clean, when to outline, how to make ramps with hue shift, how to shade without pillow shading or banding, how to anti-alias by hand, how to make tiles that repeat and animations that read, and a checklist to judge the result at its real size. Use it with the klad skill whenever you draw on a pixel layer, and before you critique pixel art.
+---
+
+# Pixel art
+
+How to make a sprite look placed by hand, pixel by pixel, by someone who knows why each one is there. The klad skill (`klad skill`, its Pixel art part) is the tool: pixel layers, the palette, `klad pixel`, `klad pixels`, `klad check`. The drawing skill (`klad skill drawing`) is the craft that holds for every picture: one focal point, one light, values first. This page is what changes when the picture is 32 pixels wide.
+
+What changes is that nothing is small enough to ignore. In a painting a stroke out of place is lost among thousands. In a 16 px sprite one pixel is a sixteenth of the width: it is an eye, a highlight or a mistake, and the viewer sees which. So pixel art is not a small painting. It is a few hundred decisions, and the work is to make every one of them on purpose.
+
+## The order of work
+
+1. **Size.** The smallest size that holds the idea. 16 px for an item or an icon, 16 to 32 for a character in a tile game, 48 to 64 for a hero or a portrait. Every doubling is four times the pixels to decide, and a large sprite drawn with small-sprite care looks empty. Size the drawing in pixels of the art (`klad new hero.klad --pixel 32x32`); enlarging is for the export.
+2. **Palette.** Decide the colours before the pixels: a handful of ramps, three to five steps each, 8 to 16 colours for a sprite. Load one (`klad palette hero.klad --load pico-8`) or build ramps (`--ramp skin --base '#d99a6c' --steps 4`). Name the colours by what they are for (`skin`, `cloth`, `ink`), so a change to the palette changes the sprite.
+3. **Silhouette.** Draw the whole figure as one flat colour and look at it at real size. If the filled shape does not say what it is, no shading will. Push what identifies it: a larger head, the hat, the weapon, the tail. Pose it off balance; a figure standing square is a box.
+4. **Flat colour.** One colour per material, each as a few simple shapes.
+5. **Light.** One direction for the whole sprite and for every sprite that will stand next to it; from the top left unless the game says otherwise. Put a shadow shape on the far side of each form and under each overhang, one ramp step down. Then the light shapes, one step up, smaller than the shadows.
+6. **Outline,** or the choice not to have one (below).
+7. **Clean up.** Lines, clusters, single pixels. Then anti-aliasing, last and sparingly.
+8. **Check.** `klad check`, then real size, then on the background it will stand on, then in motion.
+
+## Real size is the judge
+
+You draw enlarged and the player sees it small, so what you see while working is not the picture. `klad render hero.klad --scale 1` is. Look at it after every stage, and look at it next to a neighbour: a second sprite, the tile under it. Two colours that are clearly different at eight times can be the same grey at one. If two neighbouring colours do not separate at real size, they are one colour and one of them is wasted; move their values apart or drop one.
+
+## Clusters
+
+A cluster is a group of touching pixels of one colour that reads as one shape. Pixel art is built from clusters, the way a painting is built from strokes.
+
+- Make clusters simple and a little chunky: wedges, crescents, blocks with one cut corner. A shadow is a shape, not a row.
+- A single pixel with no neighbour of its colour is noise unless it is a detail the viewer should find: an eye, a glint, a button. Decide which. `klad check` lists them as stray pixels.
+- Avoid one-pixel strings of a colour running through a shape, and pixels scattered like salt. Both read as dirt.
+- Every edge between two clusters is a line and wants the care of a line.
+
+## Lines
+
+A line of pixels is a sequence of runs: so many pixels straight, then a step. Its quality is in the runs.
+
+- **No doubled corners.** Where a one-pixel line turns, the corner pixel that touches both neighbours makes an L, and the line looks thick there. Remove it, so each pixel touches the next at a side or at a corner, never both. A corner that is meant, the corner of a box, is the exception.
+- **Straight lines** repeat one run: 1, 1, 1 for 45 degrees, 2, 2, 2 for a shallow slope, 3, 3, 3, and their upright twins. Mixed runs (2, 3, 2, 2, 3) are for angles that need them, and then the pattern still repeats evenly.
+- **Curves** change their run lengths one way and then the other: 1, 1, 2, 3, 5, 3, 2, 1, 1. A run that is shorter than both its neighbours (4, 1, 4) is a jag: a step where the eye expects a sweep. Even it out.
+- `klad pixel --path` and `--line` draw clean lines for you; fix by hand with `--cells` and `--erase`.
+
+## Outlines
+
+An outline is a choice with a price: on a 16 px sprite a full outline is two of sixteen pixels in each direction.
+
+- **A dark outline all round** reads on any background. Use the darkest colour of the palette, not pure black, and let it take the hue of what it surrounds when you can afford the colours.
+- **A coloured outline:** each stretch is a darker step of the fill it borders, and on the lit side it gets lighter or goes away. The sprite sits in its world instead of on it.
+- **No outline:** for tiles, backgrounds and anything that will always stand on a known colour. Contrast with the background does the work.
+- **Inner lines** only where two parts of the same colour overlap, an arm across a chest. Elsewhere let the change of colour be the edge.
+- `klad pixel hero.klad l1 --color ink --outline` draws one round what the layer shows (`--inside` on its own edge pixels). Then break it where the light hits.
+
+## Ramps and hue shift
+
+A ramp is one material from dark to light. Darkening a colour by adding black, and lightening it by adding white, gives a ramp that looks like plastic in fog.
+
+- **Shift the hue with the value.** Shadows lean cool, towards blue and violet. Lights lean warm, towards yellow. `klad palette --ramp` makes ramps that do this.
+- **Saturation peaks in the middle.** The darkest and the lightest steps are duller than the mid-tones.
+- **Steps you can see.** Each step clearly lighter than the last at real size, with about even gaps. Three to five steps per material; a small form uses two of them.
+- **Share colours between ramps.** One dark for all the outlines and deepest shadows, one light for the brightest highlights; the shadow of skin can be the mid-tone of leather. Shared colours tie the sprite together and keep the palette small.
+- **Every colour earns its place.** `klad strokes hero.klad l1 --entry <colour>` shows where a colour is used. A colour used for three pixels should be a neighbour's colour.
+- Other colourings of the same sprite (teams, night, a hurt flash) are palette variants (`klad palette --new-variant`), which is one more reason to give each material its own palette entries.
+
+## Shading
+
+- **Shade the form, not the outline.** Pillow shading is light in the middle and darker towards every edge, whatever the light. It makes everything look like a cushion. Put the shadow on the side away from the light and under what overhangs: under the head on the chest, under the arm on the body.
+- **No banding.** Bands of colour one pixel wide that follow each other, or follow the outline, look like contour lines on a map. Vary their width, let two steps meet at an angle, or merge them. `klad check` lists them.
+- **Highlights are small** and belong to shiny things: one or two pixels on metal, an eye, wet skin. A highlight on cloth is a lighter plane, not a dot.
+- **Dither with care.** A checker of two colours makes a third at a distance, and makes noise up close. Keep it for large areas and rough materials (`klad pixel --dither 50 --second`), and off characters that move, where it shimmers.
+- **Detail is suggested.** Three pixels say brick; a full grid of mortar says graph paper. Put detail at the focal point, the face before the boots.
+
+## Anti-aliasing by hand
+
+A step in an edge can be softened with one pixel of a colour between the two that meet. That is the whole technique, and most sprites need little of it.
+
+- Use it on curves and shallow diagonals inside the sprite, where two of its own colours meet.
+- At the end of a run, extend the run with an in-between pixel. Long runs take two, short runs one, runs of one take none.
+- Never on 45 degree lines, on straight horizontals and verticals, or on the outer edge against a background you do not know: there it makes a halo.
+- The in-between colour comes from the palette. Usually a ramp step you have does it.
+- Too much of it blurs the sprite, and a row of in-between pixels along an edge is banding. If in doubt, leave the step.
+
+## Tiles
+
+- **Edges have to meet.** Draw on a canvas that wraps (`klad new grass.klad --pixel 16 --wrap`) and look at it repeated (`klad render grass.klad --repeat 3`). In a tileset (`--tile 16`), read two neighbours side by side (`klad pixels ground.klad l1 --tile 0,0`, then `--tile 1,0`).
+- **Nothing that counts.** One distinct pebble repeats every 16 px and the eye finds the grid. Spread small, similar features evenly, and make two or three versions of a tile to mix.
+- **Quieter than what stands on it.** Less contrast and less saturation than the characters, so they read against it.
+- **One light** for tiles and sprites alike.
+
+## Animation
+
+- **Few frames, strong poses.** An idle is two to four drawings, a walk four to six, an attack three to five: a pose that winds up, the strike, a pose that settles. Timing comes from how long each drawing holds, not from more drawings.
+- **Keep the volume.** A limb that loses a pixel of width on one frame flickers. Move clusters whole (`klad lasso --box x,y,w,h --cut --move 1,0`) and then repair their edges.
+- **Less than a pixel.** To move something by less than a pixel, move its shading instead of its outline: a highlight that shifts by one pixel makes a chest breathe.
+- **One pixel is a lot.** At 16 px a one-pixel squash is a big gesture. Use it on purpose.
+- **No jitter.** A pixel that changes between frames for no reason is seen. Compare each frame with the last (`klad render --frame 3 --overlay onion`), and build a frame from the one before: read it (`klad pixels hero.klad l1 --frame 0 --plain`), change the text, write it to the new frame (`klad pixel hero.klad l1 --frame 1 --grid -`).
+- **Judge it moving,** at speed and at the size it will be seen: `klad export hero.klad --gif --scale 4`. Watch the loop where the last frame meets the first.
+
+## What goes wrong, and why
+
+- **Too many colours.** Soft gradients of many close steps are a painting shrunk down. Fewer, clearer steps.
+- **Drawn enlarged, never looked at small.** Detail that only exists at eight times.
+- **Mixed pixel sizes.** Every pixel on screen must be the same size. Export at whole-number scales (klad refuses others), rotate by quarter turns only, and redraw a sprite for any other angle instead of turning it in the engine.
+- **A converted picture left as it is.** `klad pixelize` and `klad import picture.png` give a start: in-between colours along every edge, broken outlines, stray pixels. Redraw the outline, cut the colours, check it.
+- **Symmetry left in.** `--mirror-x` is a good way to start a front view; then change one side a little.
+- **Black outline, pure white highlight, primary colours.** Straight from the tube. Take them from the ramps.
+- **Everything outlined, everything shaded, everything detailed.** Then nothing leads. Choose where the sprite is richest.
+
+## Before you show it
+
+Look at `klad render --scale 1`, and check in this order:
+
+1. **Silhouette:** filled with one colour, does it say what it is?
+2. **Read:** at real size, on its background, is the focal point the first thing seen?
+3. **Palette:** how many colours, and is each one needed? Do neighbouring colours separate?
+4. **Light:** one direction, shadows as shapes, no cushion, no contour lines.
+5. **Lines:** runs that repeat or change smoothly, no doubled corners.
+6. **`klad check`:** nothing to look at, or every finding is one you meant.
+7. **Tiles:** repeated three times, is there a seam or a grid?
+8. **Animation:** as a GIF at speed: does the volume hold, does the loop close, does anything flicker?
+
+If you can name what would make it better, do that before you show it.
diff --git a/packaging/archive.sh b/packaging/archive.sh
index 6897be7..72e5274 100755
--- a/packaging/archive.sh
+++ b/packaging/archive.sh
@@ -23,6 +23,7 @@ mkdir -p "$stage/fonts"
(cd "$root/fonts" && tar cf - --exclude update.py .) | (cd "$stage/fonts" && tar xf -)
cp "$root/LICENSE" "$root/LICENSE-MIT" "$root/THIRD-PARTY-NOTICES.md" "$root/docs/skill/SKILL.md" "$stage/"
cp "$root/docs/skill/drawing/SKILL.md" "$stage/SKILL-drawing.md"
+cp "$root/docs/skill/pixel/SKILL.md" "$stage/SKILL-pixel.md"
cp "$root/packaging/icon/icon.png" "$stage/klad.png"
bash "$root/packaging/samples.sh" "${KLAD:-$stage/klad$ext}" "$stage/samples" >/dev/null
case "$platform" in
diff --git a/packaging/macos/app.sh b/packaging/macos/app.sh
index 346f9c7..4bcc7f9 100755
--- a/packaging/macos/app.sh
+++ b/packaging/macos/app.sh
@@ -32,6 +32,8 @@ mkdir -p "$app/Contents/Resources/skill"
cp "$root/docs/skill/SKILL.md" "$app/Contents/Resources/skill/"
mkdir -p "$app/Contents/Resources/skill/drawing"
cp "$root/docs/skill/drawing/SKILL.md" "$app/Contents/Resources/skill/drawing/"
+mkdir -p "$app/Contents/Resources/skill/pixel"
+cp "$root/docs/skill/pixel/SKILL.md" "$app/Contents/Resources/skill/pixel/"
bash "$root/packaging/samples.sh" "${KLAD:-$app/Contents/MacOS/klad}" "$app/Contents/Resources/samples" >/dev/null
codesign --force --deep --sign - "$app" 2>/dev/null || true
echo "$app"