Fix bad hands in NSFW AI images with a layered workflow: start with good prompts and a hand-focused negative prompt, let ADetailer auto-detect and refine hands during generation, then inpaint stubborn hands using a depth or canny ControlNet (or MeshGraphormer hand depth) to lock correct finger structure. Work in that order, regenerate before you manually fix, and most hands clean up in one or two passes.
Why AI hands break
Hands are the hardest thing for diffusion models to render because they are small, highly articulated, and appear in a huge range of poses and overlaps. The model sees a hand as a few dozen pixels with five similar protrusions that bend in many directions, so it routinely produces six fingers, fused fingers, missing thumbs, or melted knuckles. In NSFW images the problem is worse: hands often touch bodies, grip, or overlap other hands, which is exactly the configuration models handle least well.
The good news is that hands are a structure problem, and structure problems have structure solutions. You do not need to repaint fingers by hand. You need to give the model better odds (prompting), a second pass at the right resolution (ADetailer and inpainting), and a structural guide when it still gets confused (ControlNet). The rest of this guide is that ladder, in the order you should climb it. If you want to test prompts quickly before setting up a local pipeline, our free NSFW AI image generator is a fast way to see how a checkpoint handles hands before you commit to local tooling.
Step 1: Prompts and negatives
The cheapest fix is upstream. A clear prompt and a hand-targeted negative prompt raise your hit rate before any post-processing.
In the positive prompt, naming hands explicitly when they matter helps: phrases like detailed hands, five fingers, natural hand pose nudge the model. Do not overdo it, since stuffing the prompt with hand terms can actually pull the composition toward hands you did not want emphasized. In the negative prompt, the standard anatomy terms do real work.
# Hand-focused negative prompt additions:
bad hands, extra fingers, fused fingers, too many fingers,
missing fingers, mutated hands, malformed hands, extra limbs,
deformed hands, poorly drawn hands, long fingers, bad anatomyIt also helps to keep hands away from the busiest part of the composition when the pose allows it, because a hand against a clean background renders more reliably than a hand lost in overlapping limbs and fabric. You will not always have that luxury in NSFW poses, but when you do, a simpler hand context is a free quality win. Resolution is the other upstream lever: a hand that occupies 30 pixels in a 512-wide image has almost no information to work with, while the same hand in a 1024-wide generation has four times the detail and a far higher chance of correct fingers from the start.
Choice of checkpoint matters too. Some NSFW checkpoints render hands far better than others, and a good base model halves your hand problems before you start. Pony and Illustrious derivatives vary a lot here, and a few realistic SDXL merges are notably better at hands than their peers, so it is worth running the same prompt across two or three checkpoints and keeping the one whose hands need the least cleanup. The best Stable Diffusion checkpoints for NSFW roundup notes which ones handle anatomy cleanly, and a curated negative prompt master list gives a tested baseline you can paste in. There are also hand-fixing LoRAs (bad-hands embeddings and hand-detail LoRAs) you can load at low weight; the best NSFW LoRAs guide covers how to use them.
Step 2: ADetailer hand model
ADetailer (the !After Detailer extension) automatically detects regions, masks them, and inpaints each one at high resolution as part of the same generation. It ships with a hand detection model, hand_yolov8n.pt (or hand_yolov8s.pt), that finds hands and refines them without you lifting a finger.
Enable ADetailer, add a tab, and select the hand model. It will detect each hand, crop to it, regenerate at full resolution, and stitch it back. Because the hand is now being rendered at a much higher effective resolution than when it was a few pixels in the full image, the model gets the fingers right far more often. This is the same Only-masked principle that makes manual inpainting sharp, except ADetailer automates the detect-crop-fix-stitch loop for every hand it finds, so you can fire and forget. You can also raise the detection confidence threshold if it is grabbing things that are not hands, or lower it if it misses a hand that is partly hidden.
# ADetailer hand tab settings:
ADetailer model: hand_yolov8n.pt
Detection confidence: 0.3
Inpaint denoising strength: 0.4 to 0.5
Inpaint only masked: enabled
ADetailer prompt: detailed hand, five fingersKeep the ADetailer denoise modest (0.4 to 0.5). Too high and it invents a new hand in a different pose that no longer matches the wrist; too low and it does not fix the problem. A short ADetailer-specific prompt focused on the hand works better than inheriting the full scene prompt. The full ADetailer workflow, including running face and hand models together, is covered in the ADetailer NSFW guide.
Step 3: Inpaint the hand with ControlNet
When ADetailer is not enough, drop to manual inpainting with a structural guide. This is the most reliable fix for a badly broken hand. Open the image in the Inpaint tab, mask the hand plus a little of the wrist, set Inpaint area to Only masked with around 32 pixels of padding, and denoise 0.5 to 0.7.
The key addition is a ControlNet unit that supplies correct hand structure. Two approaches work:
- Depth or Canny from a good reference hand. If you have a reference image of a correct hand in roughly the right pose, run it through depth or canny and use it as the control so the model rebuilds the masked hand on a correct skeleton.
- Depth or Canny from the existing hand, lightly. Sometimes the broken hand’s overall shape is fine and only the fingers are wrong; a low-weight canny preserves the wrist and palm position while you let denoise rebuild the fingers.
# Inpaint-a-hand with ControlNet (A1111/Forge):
Inpaint area: Only masked
Only masked padding: 32
Denoising strength: 0.55
ControlNet enable: yes
ControlNet preprocessor: depth_midas # or canny
Control weight: 0.6 to 0.9
ADetailer prompt / inpaint prompt: a hand, five fingers, natural poseThe full ControlNet setup, model matching, and weight tuning are in the ControlNet NSFW guide, and the general masking and denoise mechanics are in the inpainting guide. Match the ControlNet model architecture to your checkpoint (SD1.5 vs SDXL) as always.
Step 4: MeshGraphormer depth hand
There is a purpose-built tool for exactly this: the MeshGraphormer Hand Refiner, available as a ControlNet preprocessor (depth_hand_refiner) in the sd-webui-controlnet extension. It detects the hand in your image, fits a 3D hand mesh to it, and outputs a clean depth map of a correct hand, which you then feed to a depth ControlNet during inpainting. In effect it reconstructs what the hand should look like in 3D and hands the model a correct depth guide.
This is the strongest automated hand fix short of manual work, because the depth map encodes a genuinely correct five-finger structure rather than relying on the model to invent one. Mask the hand, enable a depth ControlNet, set the preprocessor to depth_hand_refiner, weight around 0.7 to 1.0, and inpaint at denoise 0.6 to 0.75. It works best when the original hand is at least roughly hand-shaped so the mesh has something to fit; for a totally melted blob, fall back to a reference-based depth or canny.
Step 5: Regenerate vs manual fix
Know when to stop fixing and start over. If the hand is a small, ambiguous blob and nothing structural is recoverable, it is faster to regenerate the whole image with a different seed and ADetailer enabled than to fight a hopeless mask. Conversely, if the image is otherwise perfect and only one hand is wrong, inpainting with MeshGraphormer or a reference depth is worth the effort to preserve everything else.
Manual touch-up in an image editor is the last resort: roughly paint plausible finger shapes over the broken hand in a paint program, then run that edited region back through low-denoise inpainting (0.3 to 0.45) so the model cleans up your rough paint into realistic fingers. This img2img-style cleanup of a hand-painted guide is covered in the img2img guide and is surprisingly effective because you are giving the model correct structure to refine rather than asking it to invent structure.
Do this in order: the fix-hands ladder
| Step | Method | Effort | When to use |
|---|---|---|---|
| 1 | Prompt + negatives + good checkpoint | Lowest | Always, before generating |
| 2 | ADetailer hand_yolov8 | Low | Most hands, automatic |
| 3 | Inpaint + depth/canny ControlNet | Medium | Hands ADetailer misses |
| 4 | MeshGraphormer depth_hand_refiner | Medium | Broken but hand-shaped |
| 5 | Regenerate or manual paint + low-denoise | High | Hopeless blobs / last resort |
Climb the ladder in order and stop as soon as the hand looks right. Most hands are fixed by steps 1 and 2 together. Steps 3 and 4 handle the stubborn ones, and step 5 is the rare exception. Trying to jump straight to manual painting wastes time on hands that ADetailer would have fixed for free, and skipping the prompt and checkpoint work at step 1 means you fight the same problems on every single generation instead of preventing most of them upstream. The ladder works because each rung is cheaper than the one above it and catches the majority of cases, leaving only the genuinely hard hands for the expensive methods.
Multi-hand and overlapping-hand scenes
NSFW scenes frequently have two hands interacting, or hands gripping a body, which confuses detectors and structure guides alike. ADetailer will often detect and fix each hand separately, which is good, but if two hands overlap heavily it may merge them into one detection and produce a fused result. When that happens, inpaint each hand individually: mask only one hand, fix it, then mask the other. For hands gripping or touching, a depth ControlNet that captures the contact geometry holds the interaction together better than canny, which can produce floating, disconnected fingers. The reason is that depth encodes which surface is in front, so the model understands that fingers wrap around a limb rather than floating beside it, while canny only sees edges and has no sense of that overlap. When you do inpaint a contact area, mask both the hand and the small patch of skin it touches so the model can resolve the boundary cleanly instead of leaving a hard seam where a finger meets a body. Patience and one-hand-at-a-time masking beats trying to fix a tangle of hands in a single pass. Generating at a higher base resolution also gives every hand more pixels to begin with, which reduces how often you reach steps 3 and 4 at all.
Hand-fixing LoRAs and embeddings
Beyond prompts, there are trained assets that target hands directly. Negative embeddings such as the various bad-hands textual inversions act like a pre-packaged hand negative prompt: you add the embedding token to your negative field and it steers away from the malformed-hand region of the model’s latent space. Hand-detail LoRAs do the opposite, reinforcing correct finger structure when loaded at a low weight (around 0.3 to 0.5). Neither is a complete fix on its own, but both raise your base hit rate so fewer hands need post-processing. Do not load them heavy, since high weights distort the rest of the image while chasing marginal hand gains that ADetailer would have caught for free. The best NSFW LoRAs guide lists which hand and anatomy LoRAs are worth keeping in your stack. As with everything in this niche, these assets help most when paired with a checkpoint that already renders anatomy competently, so do not expect a LoRA to rescue a weak base model.
A complete fix-hands workflow in practice
Here is how the ladder plays out on a real image. You generate an NSFW portrait with a hand-aware negative prompt and ADetailer running both a face and a hand model. Eight times out of ten, the hands come out clean and you are done at step 2. On the ninth, one hand has a fused ring and pinky finger. You open the Inpaint tab, mask that hand plus the wrist, set Only masked with 32 pixels padding and denoise 0.55, enable a depth ControlNet with the depth_hand_refiner preprocessor at weight 0.8, and write a short prompt: a hand, five fingers, natural pose. One generation later the fingers separate correctly and match the wrist. You upscale, then run a final low-denoise inpaint pass at 0.3 over both hands to crisp the nails and knuckles.
The tenth image is a melted blob where a hand should be, with no recoverable structure. Rather than fight it, you regenerate with a new seed. This is the discipline that keeps a session productive: cheap fixes first, structural guides for the stubborn ones, and a fresh seed for the hopeless cases. If you would rather iterate on prompts and seeds before building this local stack, our free NSFW AI image generator lets you test how different prompts affect hand quality with no setup, then bring your best base image into A1111 or Forge for the ADetailer and ControlNet refinement steps. Over a few sessions this ladder becomes muscle memory, and bad hands stop being the thing that ruins an otherwise great image.
Frequently asked questions
What is the fastest way to fix bad hands in AI images?
Enable ADetailer with the hand_yolov8 model and a modest inpaint denoise of 0.4 to 0.5. It automatically detects each hand, regenerates it at full resolution, and stitches it back as part of the same generation, so most hands come out correct with no manual work. Combine it with a hand-focused negative prompt for the best automatic results. Only drop to manual ControlNet inpainting for hands ADetailer cannot fix.
What negative prompt terms help with hands?
Add bad hands, extra fingers, fused fingers, too many fingers, missing fingers, mutated hands, malformed hands, deformed hands, poorly drawn hands, and long fingers to your negative prompt. These steer the model away from the most common hand failures. Do not rely on negatives alone, since they reduce but do not eliminate the problem; pair them with ADetailer and a checkpoint that renders anatomy well for a meaningful improvement.
What is MeshGraphormer and how does it fix hands?
MeshGraphormer Hand Refiner is a ControlNet preprocessor (depth_hand_refiner) that detects a hand, fits a 3D hand mesh to it, and outputs a clean depth map of a correct five-finger hand. You feed that depth map to a depth ControlNet while inpainting the hand, so the model rebuilds it on genuinely correct structure rather than guessing. It is the strongest automated fix, but works best when the original hand is at least roughly hand-shaped.
What denoising strength should I use to inpaint a hand?
Use 0.5 to 0.7 when inpainting a hand with a ControlNet guide. That is high enough to rebuild broken fingers but low enough that the new hand still matches the wrist and lighting. With MeshGraphormer depth, you can push to 0.6 to 0.75 because the depth map keeps structure correct. For cleaning up a hand-painted rough guide, drop to 0.3 to 0.45 so the model refines your shapes instead of replacing them.
Should I regenerate or fix a bad hand?
Regenerate when the hand is a small ambiguous blob with nothing structural to recover, since a fresh seed with ADetailer enabled is faster than fighting a hopeless mask. Fix the hand when the rest of the image is good and only the hand is wrong, because inpainting with MeshGraphormer or a reference depth preserves everything else. The rule of thumb: protect a great image, but do not waste time rescuing a mediocre one.
Can ControlNet fix hands and which type is best?
Yes. Inpaint the hand with a depth or canny ControlNet supplying correct structure. Depth (especially MeshGraphormer depth_hand_refiner) is best for rebuilding broken fingers and for hands touching a body, because it captures contact geometry. Canny works when the hand shape is mostly fine and only fingers are wrong, preserving wrist and palm position. Match the ControlNet model to your checkpoint architecture, SD1.5 or SDXL, or it will not work.
Why does ADetailer sometimes make hands worse?
Usually the inpaint denoise is too high, so ADetailer invents a new hand in a different pose that no longer matches the wrist, or it merges two overlapping hands into one detection. Lower the denoise to around 0.4 to 0.5, use a short hand-specific ADetailer prompt instead of the full scene prompt, and for overlapping hands fix each one separately with manual inpainting rather than relying on a single ADetailer pass.
How do I fix two hands that are overlapping or gripping?
Inpaint each hand individually rather than in one pass, since detectors and ControlNet often merge overlapping hands into a fused mess. Mask one hand, fix it with a depth ControlNet that captures the contact geometry, then mask and fix the other. Depth holds interactions together better than canny, which can produce floating fingers. Generating at a higher base resolution also gives each hand more pixels, reducing how often heavy fixing is needed.
