Description

Detect and remove AI fingerprints from AI-generated images. Strip metadata, add film grain, recompress, and bypass AI image detectors. Works with Midjourney,...

README (SKILL.md)

AI Image De-Fingerprinting Skill

Name: Humanize Image
Author: swaylq

Comprehensive CLI for removing AI detection patterns from AI-generated images. Transforms detectable AI images into human-camera-like photographs using multiple processing techniques.

Supported Models: Midjourney, DALL-E 3, Stable Diffusion, Flux, Firefly, Leonardo, and more.

Quick Start

# Basic processing (medium strength)
python scripts/deai.py input.png

# Specify output file
python scripts/deai.py input.png -o output.jpg

# Adjust processing strength
python scripts/deai.py input.png --strength heavy

# Only strip metadata (fastest)
python scripts/deai.py input.png --no-metadata

# Batch process directory
python scripts/deai.py input_dir/ --batch

# Pure Bash version (no Python needed)
bash scripts/deai.sh input.png output.jpg

How It Works

AI-generated images contain multiple detection layers:

Detection Vectors

Metadata: EXIF tags revealing generation tool, C2PA watermarks
Frequency Domain: DCT coefficient patterns unique to diffusion models
Pixel Patterns: Over-smoothness, unnatural noise distribution
Visual Features: Perfect lighting, repetitive textures

Processing Pipeline

Our de-fingerprinting pipeline applies 7 transformation stages:

Input → Metadata Strip → Grain Addition → Color Adjustment → 
Blur/Sharpen → Resize Cycle → JPEG Recompress → Final Metadata Clean → Output

Stage Details

Stage	Purpose	Technique
Metadata Strip	Remove EXIF/C2PA/JUMBF tags	ExifTool
Grain Addition	Add camera sensor noise	Poisson/Gaussian noise overlay
Color Adjustment	Break color distribution patterns	Contrast/saturation/brightness tweak
Blur/Sharpen	Disrupt edge detection patterns	Gaussian blur + unsharp mask
Resize Cycle	Introduce resampling artifacts	Downscale → upscale with Lanczos
JPEG Recompress	Add compression artifacts	Quality 75 → 95 cycle
Final Clean	Ensure no metadata leakage	ExifTool re-run

Processing Strength

Choose strength based on detection risk vs quality tradeoff:

Strength	Description	Success Rate	Quality Loss
`light`	Minimal processing, preserve quality	35-45%	Very low
`medium`	Balanced (default)	50-65%	Low
`heavy`	Aggressive processing	65-80%	Medium

Success rate = percentage of images passing common AI detectors (Hive, Illuminarty, AI or Not)

Usage Examples

Single Image Processing

# Default medium strength
python scripts/deai.py ai_portrait.png

# Light processing for high-quality images
python scripts/deai.py artwork.png --strength light -o clean_artwork.jpg

# Heavy processing for stubborn detection
python scripts/deai.py midjourney_out.png --strength heavy

Batch Processing

# Process entire directory
python scripts/deai.py ./ai_images/ --batch -o ./cleaned/

# Batch with specific strength
python scripts/deai.py ./gallery/*.png --batch --strength heavy

Metadata-Only Mode

# Only strip metadata (instant, no quality loss)
python scripts/deai.py image.jpg --no-metadata

Using Bash Version

# No Python/Pillow needed, pure ImageMagick + ExifTool
bash scripts/deai.sh input.png output.jpg

# Specify strength
bash scripts/deai.sh input.png output.jpg heavy

Dependencies

Required

ImageMagick (7.0+) — Image processing engine
ExifTool — Metadata manipulation
Python 3.7+ (for deai.py)
Pillow (Python imaging library)
NumPy (for deai.py)

Check Installation

bash scripts/check_deps.sh

This will verify all dependencies and provide installation commands if missing.

Manual Installation

Debian/Ubuntu:

sudo apt update
sudo apt install -y imagemagick libimage-exiftool-perl python3 python3-pip
pip3 install Pillow numpy

macOS:

brew install imagemagick exiftool python3
pip3 install Pillow numpy

Fedora/RHEL:

sudo dnf install -y ImageMagick perl-Image-ExifTool python3-pip
pip3 install Pillow numpy

Command Reference

deai.py (Python Version)

python scripts/deai.py \x3Cinput> [options]

Arguments:
  input                 Input image file or directory (batch mode)

Options:
  -o, --output FILE     Output file path (default: input_deai.jpg)
  --strength LEVEL      Processing strength: light|medium|heavy (default: medium)
  --no-metadata         Only strip metadata, skip image processing
  --batch               Process entire directory
  -q, --quiet           Suppress progress output
  -v, --verbose         Show detailed processing steps

Examples:
  python scripts/deai.py image.png
  python scripts/deai.py image.png -o clean.jpg --strength heavy
  python scripts/deai.py folder/ --batch

deai.sh (Bash Version)

bash scripts/deai.sh \x3Cinput> \x3Coutput> [strength]

Arguments:
  input                 Input image file
  output                Output file path
  strength              light|medium|heavy (default: medium)

Examples:
  bash scripts/deai.sh input.png output.jpg
  bash scripts/deai.sh input.png output.jpg heavy

Understanding Detection

Common AI Detectors

Detector	Method	Bypass Rate
Hive Moderation	Deep learning model	50-70% (medium)
Illuminarty	Computer vision analysis	60-75% (medium)
AI or Not	Binary classification	55-70% (medium)
SynthID	Pixel-level watermark	35-50% (heavy)
C2PA Verify	Metadata check	100% (metadata strip)

What This Skill Cannot Do

❌ Not a Silver Bullet:

Cannot guarantee 100% bypass of all detectors
Advanced detectors (SynthID) require more aggressive processing
New detection methods may emerge

❌ Limitations:

Processing reduces image quality (tradeoff necessary)
Some detectors use multiple layers (metadata + pixel + frequency)
Extremely aggressive processing may introduce visible artifacts

✅ What It DOES Do:

Significantly reduces detection probability (40-80%)
Removes metadata watermarks (100% effective)
Maintains reasonable visual quality
Batch processes entire collections

Verification Workflow

Process Image:

python scripts/deai.py ai_image.png -o clean.jpg --strength medium

Test on Multiple Detectors:
If Still Detected:
- Increase strength: --strength heavy
- Try multiple passes
- Manual touch-ups (add slight noise in photo editor)
Quality Check:
- Compare original vs processed
- Ensure no visible artifacts
- Verify colors/details preserved

Advanced Usage

Custom Processing Pipeline

Edit scripts/deai.py to adjust parameters:

# Noise strength (line ~80)
noise = np.random.normal(0, 3, img_array.shape)  # Increase 3 → 5 for more grain

# Contrast adjustment (line ~95)
enhancer.enhance(1.05)  # Increase 1.05 → 1.08 for stronger effect

# JPEG quality (line ~120)
img.save(temp_path, "JPEG", quality=80)  # Decrease 80 → 70 for more compression

Combining with External Tools

# Step 1: De-fingerprint
python scripts/deai.py ai_gen.png -o step1.jpg

# Step 2: Add subtle texture overlay (GIMP/Photoshop)
# (Manual step)

# Step 3: Re-strip metadata
exiftool -all= step1_edited.jpg

Best Practices

For Social Media

Use medium strength (good balance)
Output as JPEG (universal compatibility)
Test on platform's upload flow before posting

For Professional Use

Start with light (preserve quality)
Manual review each output
Keep originals in secure storage
Document processing steps

For Research/Testing

Use heavy for stress testing
Compare multiple detectors
Document success/failure patterns

Legal & Ethical Notice

⚠️ Use Responsibly:

This tool is intended for:

✅ Personal creative projects
✅ Academic research on AI detection
✅ Security testing (authorized)
✅ Understanding detection mechanisms

DO NOT use for:

❌ Fraud or deception
❌ Impersonating human creators
❌ Bypassing platform policies without authorization
❌ Creating misleading content

Legal Risks:

Some jurisdictions (e.g., COPIED Act 2024) may restrict watermark removal
Platform terms of service often prohibit AI content masking
Commercial use may have additional legal requirements

You are responsible for compliance with applicable laws and terms of service.

Troubleshooting

"Command not found: exiftool"

# Install ExifTool
sudo apt install libimage-exiftool-perl  # Debian/Ubuntu
brew install exiftool                     # macOS

"ImportError: No module named PIL"

pip3 install Pillow numpy

"ImageMagick policy.xml blocks operation"

# Edit /etc/ImageMagick-7/policy.xml
# Change: \x3Cpolicy domain="coder" rights="none" pattern="PNG" />
# To:     \x3Cpolicy domain="coder" rights="read|write" pattern="PNG" />

Processing is slow on large images

# Pre-resize before processing
magick large.png -resize 2048x2048\> resized.png
python scripts/deai.py resized.png

Output looks too grainy/noisy

# Use light strength
python scripts/deai.py input.png --strength light

Development

Running Tests

# Test dependency check
bash scripts/check_deps.sh

# Test single image (verbose)
python scripts/deai.py test_images/sample.png -v

# Test batch mode
mkdir test_output
python scripts/deai.py test_images/ --batch -o test_output/

Contributing

Improvements welcome! Focus areas:

New detection bypass techniques
Quality preservation algorithms
Support for more image formats (HEIC, AVIF)
Integration with detection APIs

References

Detection Research:

Hu, Y., et al. (2024). "Stable signature is unstable: Removing image watermark from diffusion models." arXiv:2405.07145
IEEE Spectrum: UnMarker tool analysis

Open Source Projects:

Synthid-Bypass — ComfyUI watermark removal
C2PAC — C2PA metadata tools

Detection Tools:

Version: 1.0.0
License: MIT (for educational/research use)
Maintainer: voidborne-d
Last Updated: 2026-02-23

Usage Guidance

Technically coherent: the code implements exactly what the skill claims (local metadata removal and image transforms using ImageMagick/ExifTool/Pillow). Before installing or running it, consider these points: - Legal & policy: removing watermarks or metadata to evade detection can violate platform Terms of Service or local laws; the README includes warnings but you remain responsible for compliance. - Dual-use risk: this is a bypass tool — avoid using it for fraud, impersonation, or other unauthorized activities. - Review & sandbox: inspect the included scripts yourself (they are small and readable) and run them in an isolated environment (VM/container) before processing sensitive images. - ImageMagick policy advice: README suggests editing policy.xml in some cases — modifying system policy files can have system-wide effects; prefer non-invasive workarounds. - Data of provenance: the tool strips provenance/metadata (EXIF/C2PA); if you need to retain ownership or audit trails, back up originals first. If you want stronger assurance, ask for a full line-by-line review of scripts/deai.py and deai.sh (I can summarize any specific functions or point out risky system calls), or test processing on non-sensitive sample images and verify outputs with the detectors you care about.

Capability Analysis

Type: OpenClaw Skill Name: humanize-image Version: 1.0.0 The skill's stated purpose of de-fingerprinting AI images is legitimate, and the `SKILL.md` and `README.md` files do not contain prompt injection attempts. However, the `scripts/deai.sh` file is vulnerable to shell injection. It directly passes user-controlled input file paths (`$1`, `$2`) to `magick` and `exiftool` without sufficient sanitization. A malicious actor could craft a filename (e.g., starting with `-` or containing shell metacharacters) that could be interpreted as arbitrary commands or options by the underlying tools, potentially leading to remote code execution or information disclosure. While the Python version (`scripts/deai.py`) mitigates this by using `subprocess.run` with a list of arguments (avoiding shell interpretation), the Bash script's vulnerability makes the skill suspicious due to the high risk of exploitation, despite no clear evidence of intentional malicious design by the author.

Capability Assessment

✓ Purpose & Capability

Name/description (remove AI fingerprints) match the included scripts and README. Required tools (ImageMagick, ExifTool, Python/Pillow/NumPy) and the implemented pipeline (metadata strip, noise/grain, color/blur/sharpen, resize, JPEG recompress) are appropriate and expected for the declared functionality.

ℹ Instruction Scope

SKILL.md and the scripts restrict actions to local image processing (file reads/writes, temporary files, running exiftool/magick). There are no network calls or hidden endpoints in the provided code. Note: the instructions explicitly describe bypassing AI detectors — this is coherent with the tool but is an explicit bypass capability with ethical/legal implications.

✓ Install Mechanism

No remote download/extract install is included; the skill is instruction/code-only and relies on standard system packages and Python libs and provides a dependency checker and package manager install hints. No suspicious external URLs or shorteners are used in install steps.

✓ Credentials

The skill declares no required environment variables, no credentials, and no config paths. The code accesses only local files provided by the user and temporary directories (/tmp). No secret access or unrelated service tokens are requested.

✓ Persistence & Privilege

The skill is not always-enabled, does not require persistent system-wide changes, and modifies only its own temporary files and outputs. It does not alter other skills or agent-wide config.

Version History

v1.0.0

Initial release of humanize-image: Remove AI fingerprints from images to bypass AI detectors. - Detects and removes metadata (EXIF, C2PA, etc.) from AI-generated images. - Applies film grain, color tweaks, resampling, blur/sharpen, and JPEG recompression to break AI detection patterns. - Supports models including Midjourney, DALL-E, Stable Diffusion, and others. - Offers three processing strengths (light, medium, heavy) for quality vs. detection risk balance. - Includes both Python (Pillow/NumPy) and pure Bash (ImageMagick/ExifTool) processing options. - Enables batch processing and metadata-only stripping modes.

Metadata

Slug humanize-image

Version 1.0.0

License —

All-time Installs 0

Active Installs 0

Total Versions 1

Frequently Asked Questions

What is Humanize Image?

Detect and remove AI fingerprints from AI-generated images. Strip metadata, add film grain, recompress, and bypass AI image detectors. Works with Midjourney,... It is an AI Agent Skill for Claude Code / OpenClaw, with 548 downloads so far.

How do I install Humanize Image?

Run "/install humanize-image" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Humanize Image free?

Yes, Humanize Image is completely free (open-source). You can download, install and use it at no cost.

Which platforms does Humanize Image support?

Humanize Image is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Humanize Image?

It is built and maintained by Sway Liu (@swaylq); the current version is v1.0.0.

More Skills

Humanize Image