The reliable NSFW AI finishing workflow runs in a fixed order: generate a base image, refine it with img2img, inpaint problem areas, run ADetailer on faces and hands, upscale with hires fix or Ultimate SD Upscale, then do a final color and contrast pass. Each stage fixes a different class of problem, and doing them out of order wastes effort by upscaling flaws or recoloring before the structure is right.
Why order matters
Finishing an AI image is a pipeline, not a single button. Each stage operates at a different scale: composition first, then regional fixes, then fine facial and hand detail, then resolution, then global color. If you upscale before fixing a broken hand, you have just rendered the broken hand in higher resolution and made it harder to repaint. If you color-grade before inpainting, your inpaint pass has to match a graded look and the new pixels stand out. The order exists because each stage assumes the previous one is done.
Think of it like editing a photo: you would not sharpen and grade a shot before you had cropped and removed the blemishes. Same logic here. Get the structure right at low cost, fix the obvious defects, then spend the expensive compute (upscaling) only on an image that is already correct, and finish with the cheap global pass (color) last so it ties everything together.
This post is the capstone for the advanced control cluster. Each stage links to a dedicated guide where the technique is covered in depth. If you do not have a local install yet, you can generate a base image in our free NSFW AI image generator and bring it into a local pipeline for the finishing stages, since refinement and inpainting need local tools.
Stage 1: Generate the base
Everything downstream depends on a solid base. Spend your seeds here, not later. Generate a batch, judge composition and pose, and pick the strongest candidate before doing any finishing work. A great finishing pipeline cannot rescue a fundamentally broken generation, so it is cheaper to regenerate than to repair structural problems.
At this stage, use your pose and composition controls. ControlNet OpenPose locks the stance, Regional Prompter separates multiple characters, and IPAdapter or a LoRA holds a consistent identity. Resolve as much as possible here: pose, framing, character, scene. The base should be at the model’s native resolution (512 for SD1.5, 1024 for SDXL) so anatomy comes out coherent before any upscaling. Pick the candidate where the big things are right even if the small things (hands, fine face detail) are not, because those small things are exactly what the later stages fix.
Stage 2: Refine with img2img
Once you have a keeper, an img2img pass at low to moderate denoise tightens the whole image without changing its content. Run the same or a refined prompt at denoise 0.3 to 0.5. This smooths noise, improves coherence, and lets you nudge details (lighting, skin texture, minor prompt additions) while keeping the composition you chose.
Keep denoise low here. Above about 0.5 you start changing the image rather than refining it, and you risk losing the pose or face you selected. This stage is optional when the base is already clean, but it is a cheap way to lift overall quality before the targeted fixes. Our img2img guide covers denoise behavior in detail. A common pattern is a single 0.35 pass to consolidate the image, then straight into inpainting.
Stage 3: Inpaint problem areas
Now fix the specific defects: a wonky background element, an awkward fold of fabric, a misplaced anatomical detail, anything localized. Inpainting masks just the problem region and regenerates only that, at denoise 0.4 to 0.7 depending on how much change you need. Small touch-ups want low denoise; replacing a whole region wants higher.
Do this before upscaling so you are repainting at a manageable resolution, and before ADetailer so faces and hands are handled by the tool built for them rather than by general inpainting. Mask with a few pixels of blur to blend the repaint, and match the prompt to what should be in the masked area only. Our inpainting guide walks through masking, mask blur, and “inpaint masked vs whole picture” settings. Inpaint one region at a time and accept each fix before moving to the next, rather than masking the whole image and hoping.
Stage 4: ADetailer for faces and hands
ADetailer automatically detects faces (and with the right model, hands) and inpaints each one at higher effective resolution, which is why AI faces go from soft to sharp after this pass. It is the single highest-impact quality step for portraits and any image where the face matters.
Run ADetailer with a face model (face_yolov8n or similar) and, for hands, a hand detection model. Set inpaint denoise around 0.3 to 0.4 for faces so the identity is preserved while detail sharpens; hands often need a touch more. The detailer crops each detected region, regenerates it at full resolution, and composites it back, so a face that was 80 pixels wide in the frame gets rendered as if it filled the canvas. Our ADetailer faces guide covers model selection and denoise tuning, and hands deserve their own attention in the fix hands guide, since they are the most failure-prone part of any figure.
Stage 5: Upscale
With structure, defects, and faces handled, now add resolution. Two common methods:
Hires fix (txt2img, integrated):
Upscaler: 4x-UltraSharp or R-ESRGAN 4x+
Upscale by: 1.5 to 2.0
Hires steps: 10 to 20
Denoising strength: 0.3 to 0.4
Ultimate SD Upscale (img2img script, for large/2x+):
Upscaler: 4x-UltraSharp
Target: 2x to 4x
Tile size: 512 (SD1.5) / 1024 (SDXL)
Denoise: 0.2 to 0.35
Seams fix: enabledHires fix is built into txt2img and is simplest for a moderate bump. Ultimate SD Upscale (an img2img script) tiles the image, upscales each tile with a diffusion pass, and stitches them, letting you reach large resolutions without running out of VRAM. Keep upscale denoise low (0.2 to 0.4) so the upscaler adds detail without altering content; higher denoise reintroduces the defects you just fixed. Enable the seams fix in Ultimate SD Upscale to avoid visible tile boundaries. On low-VRAM cards, tiled upscaling is what makes high resolution possible at all; see our low-VRAM checkpoints guide.
Stage 6: Final color and contrast pass
Last, a global color and contrast pass ties the image together. This can be a light img2img pass at very low denoise (0.15 to 0.25) with color-oriented prompt terms, or an external edit in any photo editor for curves, white balance, and contrast. Doing it last means the grade applies to a finished, full-resolution image, so nothing you do later disturbs it.
Keep this restrained. The goal is cohesion: unify the lighting, deepen contrast slightly, correct any color cast introduced by upscaling. Heavy grading at this stage can crush detail you worked to create. A subtle pass is almost always better than an aggressive one. If you used multiple inpaint and ADetailer passes, this final step is also where small tonal mismatches between repainted regions and the original blend away.
The full workflow at a glance
This table is the workflow as a reference card. Run top to bottom; each row assumes the rows above are done.
| Stage | Tool | Key settings | Why this order |
|---|---|---|---|
| 1. Generate base | txt2img + ControlNet / Regional Prompter | Native res, fixed seed on keeper | Structure must be right before anything else |
| 2. Refine | img2img | Denoise 0.3 to 0.5 | Tightens coherence without changing content |
| 3. Inpaint | Inpaint tab | Denoise 0.4 to 0.7, mask blur 4 to 16 | Fix local defects at low resolution |
| 4. Detail faces/hands | ADetailer | Face denoise 0.3 to 0.4, hand model on | Targeted high-res repaint of the hardest regions |
| 5. Upscale | Hires fix / Ultimate SD Upscale | Denoise 0.2 to 0.4, 1.5x to 4x | Add resolution only to a correct image |
| 6. Color pass | img2img low denoise / editor | Denoise 0.15 to 0.25 | Global grade on the finished full-res image |
Not every image needs all six stages. A clean portrait might skip the refine pass and the inpaint stage entirely, going base, ADetailer, upscale, color. A complex multi-character scene might loop through inpaint several times. The order stays the same even when you skip stages; you never move a later stage earlier.
Adapting the workflow to your image
The pipeline is a default, not a straitjacket. Read the image and decide which stages it needs:
Simple solo portrait, clean base: base, ADetailer face, upscale, light color. Four stages, fast.
Multi-character scene: base with Regional Prompter and OpenPose, then heavy inpainting on the contact zones and any merged anatomy, then ADetailer on each face, then upscale. The inpaint stage carries the most weight here. Our Regional Prompter guide and OpenPose guide feed this stage.
Consistent recurring character: base with IPAdapter or a LoRA, then a face inpaint or ADetailer pass to reinforce identity, then upscale. See the character consistency guide.
Reframing or aspect-ratio change: insert an outpaint stage between base and inpaint, then continue normally. Covered in our outpainting guide.
The mistake to avoid is reordering. Upscaling before fixing hands, grading before inpainting, or detailing a face before settling the composition all create rework. Diagnose what the image needs, skip stages that do not apply, but keep the surviving stages in sequence.
Common workflow mistakes
A few errors show up again and again, and all of them come from breaking the order or rushing a stage.
Upscaling a flawed base. The most expensive mistake. You spend minutes upscaling, then notice the hand is broken and have to repaint at high resolution. Always fix structure and details first.
Too much denoise on the refine or upscale pass. High denoise reintroduces variation and can undo your fixes or alter the face. Refine stays at 0.3 to 0.5; upscaling stays at 0.2 to 0.4. When in doubt, lower it.
Inpainting the whole image at once. Masking the entire frame and regenerating defeats the purpose of inpainting. Work one region at a time, accept each fix, then move on. This keeps every repaint local and controllable.
Skipping ADetailer on small faces. A face that occupies a small fraction of the frame will almost always be soft straight from the model. ADetailer is the cheapest large quality gain available; running it is rarely the wrong call for any image with a visible face.
Grading too early or too hard. Color before inpainting forces every repaint to match the grade, and heavy grading crushes detail. Keep it last and keep it gentle.
Treating the pipeline as rigid. The opposite failure: running all six stages on an image that needed three, wasting time on passes that change nothing. Diagnose, then run only what helps.
How this ties the cluster together
Each earlier guide in this cluster handles one stage of this pipeline, and this workflow is where they connect. Composition controls (Regional Prompter, OpenPose, ControlNet) live in stage one. Reframing (outpainting) slots in after the base. Identity (IPAdapter, LoRA) is set at the base and reinforced at the ADetailer stage. Local repair (inpainting) is stage three, and the hardest local repair of all, hands, has its own dedicated approach. Faces are stage four. Reading the individual guides teaches each technique; this post teaches the sequence that makes them add up to a finished image.
The mental shift that separates beginners from people who reliably produce polished work is exactly this: they stop thinking about a single generation and start thinking about a pipeline. The model produces a draft. The pipeline produces the result. Once you internalize that, your prompt-and-pray hit rate stops mattering as much, because you have a dependable process for turning a decent draft into a finished image regardless of how the first generation landed.
A repeatable finishing routine
Put it together into a habit:
- Generate a batch, pick the best base, lock its seed.
- Optional img2img refine at 0.35 to consolidate.
- Inpaint each local defect, one region at a time, low to moderate denoise.
- ADetailer pass for faces, plus a hand model if hands are visible.
- Upscale with hires fix or Ultimate SD Upscale at low denoise.
- Subtle global color and contrast pass to finish.
- Review at full size; loop back to inpaint only if something specific is still wrong.
This sequence turns a rough generation into a finished image predictably. You can sketch and choose a base in the browser generator to save local compute on the exploratory part, then bring the winner into this local pipeline for finishing. The images that look professionally finished almost never came out of the model that way; they went through this chain. Internalize the order, learn which stages a given image actually needs, and your hit rate on polished, usable results climbs sharply. The order is the method.
Save a reusable preset for each stage once you find settings that work for your checkpoint, so you are not rediscovering the same denoise values every session. Over time the whole routine becomes muscle memory: glance at the base, decide which stages it needs, and run them in order without second-guessing. That consistency is what lets you produce a coherent set of finished images rather than a handful of lucky one-offs, and it scales from a single picture to an entire project without changing. The first few times you run the full chain it will feel slow and deliberate, but the payoff is reliability: you stop gambling on a perfect first generation and start treating every decent draft as raw material you can finish. That shift, from chasing the perfect roll of the dice to running a dependable process, is the single biggest jump in output quality most people make, and it is what every other guide in this cluster ultimately feeds into.
Frequently asked questions
Why should I upscale last instead of first?
Upscaling multiplies whatever is in the image, including defects. If you upscale before fixing a broken hand or a soft face, you simply render those flaws at higher resolution and make them harder and more expensive to repaint. Upscaling is also the most compute-heavy stage, so you want to spend it only on an image whose structure, defects, and faces are already correct. Add resolution to a finished image, not a draft.
What denoise should I use for the img2img refine stage?
Keep it between 0.3 and 0.5. That range tightens coherence, smooths noise, and lets you nudge minor details while preserving the composition, pose, and face you chose from the base batch. Above roughly 0.5 the model starts changing the image rather than refining it, risking the loss of the exact pose or identity you selected. A single 0.35 pass to consolidate before inpainting is a common, safe pattern.
Do I need every stage in the workflow for every image?
No. The order is fixed but stages are skippable. A clean solo portrait might go base, ADetailer, upscale, color, skipping the refine and inpaint stages entirely. A complex multi-character scene might loop through inpainting several times. Read each image and run only the stages it needs, but never move a later stage earlier; upscaling before fixing hands or grading before inpainting always creates rework.
What is the difference between hires fix and Ultimate SD Upscale?
Hires fix is built into txt2img and applies a single upscaling pass with a diffusion refinement, ideal for a moderate 1.5x to 2x bump. Ultimate SD Upscale is an img2img script that tiles the image, upscales each tile with its own diffusion pass, and stitches them with a seams fix, letting you reach large resolutions without exhausting VRAM. Use hires fix for convenience and Ultimate SD Upscale for big or low-VRAM upscales.
Why run ADetailer before upscaling rather than after?
ADetailer crops each detected face or hand, regenerates it at full resolution, and composites it back, so it effectively upscales those regions already. Running it before the global upscale means the face is rendered correctly at a manageable size, then the whole image is enlarged uniformly. Running it after the upscale wastes compute and can produce a face that does not match the now higher-resolution surroundings. Faces and hands first, global resolution second.
When should I add an outpainting stage to the workflow?
Insert outpainting between the base generation and the inpaint stage whenever you need to change the aspect ratio, reveal more of a cropped body, or zoom out from the original frame. Extend the borders in modest passes, update the prompt to describe the new content, then continue with inpainting, ADetailer, upscaling, and color as normal. Outpainting before detailing means the new regions get the same finishing passes as the original.
How heavy should the final color pass be?
Restrained. The goal is cohesion, not transformation: unify lighting, deepen contrast slightly, and correct any color cast introduced by upscaling. Use a very low denoise around 0.15 to 0.25 if doing it as an img2img pass, or gentle curves and white-balance adjustments in a photo editor. Heavy grading at this stage can crush the detail you worked to create across the earlier stages, so a subtle pass almost always beats an aggressive one.
Can I do the whole workflow in ComfyUI?
Yes, and many people build the entire chain as a single graph: base generation with ControlNet and IPAdapter nodes, an img2img refine, inpaint nodes for local fixes, a face-detailer node equivalent to ADetailer, an upscale group, and a final color adjustment. The advantage is that one click runs the whole pipeline reproducibly. The order and denoise principles are identical to the A1111 workflow; only the interface differs.
