Skip to content
Skills Library
Design & UX · Planning

pose-blocking

/pose-blocking

Block a human pose like a stage director before you generate or shoot it. Turns a vague pose idea ("leaning on one leg, hand on hip, looking down the street") into a pose card with explicit support, weight, joint angles, touches and camera; checks it for balance, floating supports, impossible joints, missed touches and foreshortening; builds OpenPose-style keypoints and skeleton images in six camera views plus a pose-only prompt; then reviews each generated image against nine named defects and says whether to keep, repaint a region, rerun, or re-block. Use for image/video generation with pose

Licence
MIT
Last repository change
30.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Block a human pose like a stage director before you generate or shoot it. Turns a vague pose idea ("leaning on one leg, hand on hip, looking down the street") into a pose card with explicit support, weight, joint angles, touches and camera; checks it for balance, floating supports, impossible joints, missed touches and foreshortening; builds OpenPose-style keypoints and skeleton images in six camera views plus a pose-only prompt; then reviews each generated image against nine named defects and says whether to keep, repaint a region, rerun, or re-block. Use for image/video generation with pose

Triggers from the description

leaning on one leg, hand on hip, looking down the street
Original author description

Block a human pose like a stage director before you generate or shoot it. Turns a vague pose idea ("leaning on one leg, hand on hip, looking down the street") into a pose card with explicit support, weight, joint angles, touches and camera; checks it for balance, floating supports, impossible joints, missed touches and foreshortening; builds OpenPose-style keypoints and skeleton images in six camera views plus a pose-only prompt; then reviews each generated image against nine named defects and says whether to keep, repaint a region, rerun, or re-block. Use for image/video generation with pose

How it works

  1. What this is
  2. When to use it
  3. The pose card
  4. Steps
  5. Example
  6. Tips
Original SKILL.md headings · 123 lines, 1,920 words
SKILL.md preview
---
name: pose-blocking
description: Block a human pose like a stage director before you generate or shoot it. Turns a vague pose idea ("leaning on one leg, hand on hip, looking down the street") into a pose card with explicit support, weight, joint angles, touches and camera; checks it for balance, floating supports, impossible joints, missed touches and foreshortening; builds OpenPose-style keypoints and skeleton images in six camera views plus a pose-only prompt; then reviews each generated image against nine named defects and says whether to keep, repaint a region, rerun, or re-block. Use for image/video generation with pose control, character sheets, illustration and comic reference, photo-shoot posing notes, and animation key poses.
---

# pose-blocking

[中文](SKILL.zh-CN.md)

## What this is

Most bad character images are not bad because of the style. They fail on the body: the weight sits on no foot, a "hand on the hip" lands in mid-air, a left hand becomes a right hand when the figure turns away, a kneeling figure floats a few centimetres above the floor. Text prompts describe a pose loosely, so the model fills in the rest and you burn generations hoping for a lucky one.

Stage directors solve the same problem with *blocking*: before the scene runs, every actor's position, weight and gesture is written down and walked once. This skill does that for a single figure. You turn the idea into a **pose card**, a short JSON file that names what touches the ground, where the weight goes, how each joint bends and where the camera stands. A small standard-library script checks the card like a physical body would. It then gives you three things to steer a generator: a skeleton image, keypoint JSON, and a prompt that describes only the pose. After each generation you fill a nine-line review sheet, and the script tells you the cheapest next move.

What it solves:

- **Physically wrong poses get caught before generation.** Balance, support contact, joint ranges and hand-to-body touches are computed, not guessed.
- **Pose and style stay apart.** The pose block is reused unchanged across retries, so you can see whether a change in style also moved the body.
- **The camera is part of the pose.** The same reach reads well from the side and collapses into a dot from the front. The checker flags limbs that point at the lens, and you can render all six views to pick the readable one.
- **Retries become decisions.** A six-fingered hand needs a local repaint, not a new seed. A figure that keeps drifting from the card needs a simpler card, not more attempts.

## When to use it

Use it when:

- a generated person keeps coming out in the wrong pose, or the same pose is needed across several images or shots;
- you drive a model with pose control (an OpenPose-style ControlNet, a pose or reference input, a depth or 3D-mannequin pass) and need a correct skeleton for it;
- you are writing posing directions for a photo shoot, an illustrator, a comic page or an animation key pose and want them unambiguous;
- the pose has a load-bearing detail such as weight on one leg, sitting at a real chair height, kneeling, a hand on a surface, or a hand touching the face.

Skip it for crowds, tiny background figures, abstract or non-human characters, or when any pose is fine.

### Boundaries

- Work with general poses for illustration, photography, fitness, fashion, animation, comics and games. Do not use this skill to sexualise anyone, and never for content involving minors.
- Do not pose a real, identifiable person in a generated image without that person's consent.
- The body model is a simplified adult figure measured in head heights. It is a planning aid, not motion capture or medical advice. Do not use it to judge whether a stretch or exercise is safe for someone.

## The pose card

One JSON object. Every angle is in degrees and every field is optional except `support`. **`L_` and `R_` always mean the figure's own left and right.**

| Field | Meaning |
| --- | --- |
| `intent` | One line on what the person is doing and why, e.g. "waiting at a bus stop, relaxed". |
| `support` | What carries the body: `L_foot`, `R_foot`, `L_knee`, `R_knee`, `L_hand`, `R_hand`, `seat`, `back`. Add `@height` for a raised surface in head heights, e.g. `seat@1.7` is a normal chair. |
| `weight` | For two-foot stances: `L`, `R` or `even`. |
| `root` | Whole-body tilt: `yaw` (turn, positive turns toward the figure's left), `lean_forward`, `lean_side` (positive toward the left; it also drops the opposite hip). |
| `torso` | Hinge at the hips: `bend_forward`, `bend_side`, `twist` (chest turns toward the left when positive). |
| `head` | `turn` (positive left), `nod` (positive chin down), `tilt` (positive ear toward the left shoulder). |
| `arms.L` / `arms.R` | `raise` (out to the side, 0 hanging, 90 horizontal, 180 overhead), `forward` (swing to the front), `elbow` (0 straight), `elbow_dir` (`front`, `in`, `back`, `up`, `out`: which way the forearm folds). |
| `legs.L` / `legs.R` | `out` (to the side), `forward` (hip flexion; 90 is a seated thigh), `knee` (0 straight; the shin folds backward). |
| `touch` | List of `{"hand": "R_hand", "to": "R_hip"}`. Targets: head, face, chin, neck, chest, belly, L/R_hip, L/R_knee, L/R_hand, L/R_shoulder, L/R_ankle. |
| `hands`, `gaze` | Free text. The script cannot see fingers or eyes, so say what they do. |
| `motion` | `true` when the figure is mid-action (jumping, running, falling). Balance then becomes a note, not an error. |
| `leaning_on` | Name the wall, rail or partner that takes weight outside the base. It has the same effect on balance as `motion`. |
| `camera` | `view`: `front`, `three_quarter`, `side`, `back`, `high`, `low`. `framing`: `full`, `knees`, `waist`, `chest`. |

Root lean tips the whole body, legs included, like a tree falling. Torso bend folds at the hips while the legs stay put. Most "leaning forward" poses are torso bends.

## Steps

1. **Write the intent and the support first.** Ask what touches the floor or a surface and where the weight goes. If you can't answer, you don't have a pose yet. Pick chair and step heights from real furniture: a chair seat is about 1.7 head heights and a bar stool about 3.
2. **Set the big masses, then the limbs.** Start with the pelvis (`root`), then the chest (`torso`), then the head. Limbs come last. A relaxed standing pose almost always has the pelvis tilting toward the free leg and the chest tilting back the other way.
3. **Declare every contact.** A hand on a hip, a chin on a fist or fingers on a shoe goes in `touch`. Any limb that bears weight goes in `support`.
4. **Choose the camera on purpose.** Use the view in which the main gesture is broad and flat to the lens. Reaches toward the camera need the side or three-quarter view, or a depth reference.
5. **Run the checker.** `python3 scripts/pose.py check card.json`. Exit 0 means clean, 1 means notes only, 2 means errors, 4 means the card can't be read. Fix every error by changing one or two angles at a time and run it again. Don't silence a finding by deleting the claim that caused it unless the claim was wrong.
6. **Build the control pack.** `python3 scripts/pose.py build card.json -o out --png`. You get `keypoints_<view>.json` in the common OpenPose 18-point layout, `skeleton_<view>.svg` and `.png` drawn on black, `prompt.txt` and `report.json`. Look at the skeletons for all six views and confirm the hero view reads the way you meant.
7. **Pick a control route.**
   - The generator accepts a pose skeleton: give it `skeleton_<hero>.png` (or the keypoints) together with the pose prompt.
   - It only accepts a reference image: pose a 3D mannequin or take a phone photo matching the skeleton, then use that.
   - It is text only: use the pose prompt, keep the framing generous, and expect more retries. Foreshortened limbs rarely survive text alone.
8. **Keep pose and style in separate blocks.** Paste the pose paragraph unchanged. Identity, clothing, lighting and style go in their own block. Change one block at a time between retries.
9. **Review every keeper with the nine checks** and fill a sheet like `examples/review-sheet.json`:
   - `HANDS`: right finger count, no fused or melted fingers, the grip makes sense.
   - `FACE`: the face is intact and turned the way the card says.
   - `GAZE`: the eyes look where the card says.
   - `LIMB_COUNT`: two arms and two legs, nothing extra or missing.
   - `MERGE`: no limb passes through the body, a prop or another person.
   - `FLOAT`: the supports really touch their surface (contact shadow, compressed cushion, flat sole).
   - `CROP`: nothing load-bearing is cut off by the frame in a way that changes the read.
   - `DRIFT`: each joint named in the card is roughly where the card puts it.
   - `MIRROR`: left and right are not swapped.
   Then run `python3 scripts/pose.py review sheet.json`:
   - `KEEP` (exit 0): every check passed.
   - `LOCAL_FIX` (1): only hands, face or gaze failed, so repaint that region and keep the rest.
   - `RERUN` (2): same pose block, new seed, stronger control. Change nothing else.
   - `REBLOCK` (3): the pose itself drifted or mirrored again on a second attempt, so simplify the card or pick a clearer view before generating more.
10. **Record what held.** Keep the card, the hero view and the control strength that worked next to the image. That set is your reusable pose for the next shot of the same character.

## Example

The idea was "waiting at a bus stop, weight on one leg, hand on hip, looking down the street".

```json
{
  "intent": "waiting at a bus stop, relaxed",
  "support": ["L_foot", "R_foot"], "weight": "L",
  "root": {"lean_side": -8},
  "torso": {"bend_side": 10, "twist": 5},
  "head": {"turn": -15, "tilt": -5},
  "arms": {"L": {"raise": 8, "elbow": 10},
           "R": {"raise": 30, "forward": -10, "elbow": 90, "elbow_dir": "in"}},
  "legs": {"L": {"out": 0}, "R": {"out": 14, "forward": 15, "knee": 10}},
  "touch": [{"hand": "R_hand", "to": "R_hip"}],
  "hands": "right hand loosely on the right hip, left hand relaxed",
  "gaze": "down the street to the right",
  "camera": {"view": "three_quarter", "framing": "full"}
}
```

A first draft tilted the pelvis the wrong way (`lean_side: 6`), bent the free knee 18 degrees and folded the elbow to 115. The checker answered `SUPPORT_FLOAT: R_foot hangs 0.38 H above its surface` and `TOUCH_MISSED: R_hand is 0.74 H from R_hip`. Tilting the pelvis the other way (`lean_side: -8`, so the right hip drops), nearly straightening the free knee and folding the elbow to 90 fixed both, and `check` now reports `CLEAN`. The built prompt begins: *"Full-body shot, three-quarter view, eye level. Action: waiting at a bus stop, relaxed. Pose: standing with weight on the left leg. Left hip higher than the right, head turned to the right. …"*

The first generation had six fingers on the hip hand and everything else right. The review sheet with `HANDS: fail` returned `LOCAL_FIX`, so only the hand was repainted.

`examples/` also holds a seated reader, a figure kneeling to tie a shoe, and a deliberately broken lean that shows six findings at once.

## Tips

- **Weight first, always.** If the weight claim and the centre of mass disagree, viewers feel the pose is wrong even when they can't say why.
- **One support short is fine on purpose.** Lift a foot out of `support` for a step or a kick, and set `motion` if the body is mid-action.
- **Watch the `FORESHORTENED` note.** A limb pointing at the lens is where text prompts fail most. Change the view or add a depth or mannequin reference.
- **Back views swap sides.** When the figure faces away, write "her own left hand" style wording and check `MIRROR` first.
- **Keep the pose block frozen** while you change style. If the body moves when only the style changed, raise the control strength rather than rewording the pose.
- **Real units help.** One head height is roughly 22 to 24 cm for an adult. Convert furniture to head heights before you set `@height`.
Files in this package (6)
  • .gitignore 1 KB
  • LICENSE 1 KB
  • README.md 6 KB
  • README.zh-CN.md 6 KB
  • SKILL.md 12 KB
  • SKILL.zh-CN.md 12 KB

Versions

The database has no other skills named pose-blocking.

Database snapshot: 13.11.2026 · package version 676b96403e28 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 86zbrush-pose-presentation
    Use when the task is to pose a model and produce consistent review renders.
  • 100avatar-pose-seeds
    Turn a natural-language prompt or preset id into a deterministic pose seed and joint-rotation map for a rigged humanoid avatar with @three-ws/pose. Use when an agent needs to pose an avatar reproducibly.
  • 90catimation-director-stage
    Drive the 3D Director Stage (导演台) in the CATIMATION desktop app: place models/mannequins, pose characters, play the ≈2000-clip animation library, author custom pose-keyframe animations (K 动画), set lights/color grading, manage camera slots, and record camera-move videos. Trigger…
  • 100ai-gallery
    Fetch pose, depth, costume and face reference images from AI reference galleries for GPT Image, Nano Banana, ComfyUI, H3 and other generation tools. Libraries: ギア POSE-DB-01 (pose mannequins), POSE-DB-02 (depth), COSTUME-DB-01 (costumes), あぎ face DB, CC0 pose library shisei. Use…
  • 90reference-role-mapping
    Use when the task is to assign clear subject, pose, camera, environment, palette, and style roles to references.
  • 86concept-art
    Generate concept art for a saved character-forge character on fal.ai — a front/back A-pose model sheet posed by a figure built on the character's own proportions, or the character in the pose of any picture the user gives. Checks every result against the card's look and…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.