playbooks

home / skills / humanizerai / agent-skills / humanize

humanize skill

/skills/humanize

This skill remodels AI-generated text into natural human writing, improving readability and lowering detectability while showing before/after scores and

npx playbooks add skill humanizerai/agent-skills --skill humanize

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.1 KB
---
name: humanize
description: Transform AI-generated text into natural, human-like content that bypasses AI detectors like GPTZero, Turnitin, and Originality.ai. Uses credits based on word count.
user-invocable: true
argument-hint: "[text to humanize] [--intensity light|medium|aggressive]"
allowed-tools: WebFetch
---

# Humanize AI Text

Transform AI-generated content into natural, human-like writing using the HumanizerAI API.

## How It Works

When the user invokes `/humanize`, you should:

1. Parse $ARGUMENTS for text and optional --intensity flag
2. Call the HumanizerAI API to humanize the text
3. Present the humanized text with before/after scores
4. Show remaining credits

## Parsing Arguments

The user may provide:
- Just text: `/humanize [their text]`
- With intensity: `/humanize --intensity aggressive [their text]`

Default intensity is `medium`.

## Intensity Levels

| Value | Name | Description | Best For |
|-------|------|-------------|----------|
| `light` | Light | Subtle changes, preserves style | Already-edited text, low AI scores |
| `medium` | Medium | Balanced rewrites (default) | Most use cases |
| `aggressive` | Bypass | Maximum bypass mode | High AI scores, strict detectors |

## API Call

Make a POST request to `https://humanizerai.com/api/v1/humanize`:

```
Authorization: Bearer $HUMANIZERAI_API_KEY
Content-Type: application/json

{
  "text": "<user's text>",
  "intensity": "medium"
}
```

## Response Format

Present results like this:

```
## Humanization Complete

**Score:** X → Y (improvement)
**Words Processed:** N
**Credits Remaining:** X

---
### Humanized Text

[The humanized text]

---

[Recommendation based on final score]
```

## Credit Usage

- 1 word = 1 credit
- Detection is free
- Check credits at https://humanizerai.com/dashboard

## Error Handling

### Insufficient Credits
If the user doesn't have enough credits:
1. Show how many credits are needed vs available
2. Direct them to https://humanizerai.com/dashboard to top up

### Invalid API Key
1. Check HUMANIZERAI_API_KEY environment variable
2. Direct to https://humanizerai.com to get a key

### Rate Limit
If rate limited, suggest waiting or upgrading to Business plan.

Overview

This skill transforms AI-generated text into natural, human-like writing that aims to bypass common AI detectors such as GPTZero, Turnitin, and Originality.ai. It uses a credit system based on word count and offers adjustable intensity levels to balance fidelity and detection avoidance. Results include before/after detection scores and remaining credits. The default intensity is medium for balanced rewrites.

How this skill works

When invoked, the skill parses the input text and an optional --intensity flag (light, medium, aggressive). It sends a humanization request to the HumanizerAI service, receives the rewritten text and score changes, then presents a summary with words processed and credits remaining. The skill also handles common errors like insufficient credits, invalid API keys, and rate limits and provides guidance to resolve them.

When to use it

  • You have AI-origin content that must read as natural human writing.
  • You need lower AI-detection scores for submission to detectors or similarity checks.
  • You want control over rewrite strength via light, medium, or aggressive modes.
  • You need a quick before/after comparison including detection scores and credit usage.
  • You need to audit credit consumption on a per-request basis.

Best practices

  • Start with default medium intensity; escalate to aggressive only when detectors flag the text repeatedly.
  • Provide focused input (single piece of content per call) to minimize credit waste and improve quality.
  • Check the before/after scores and tweak intensity rather than re-running multiple times.
  • Keep an eye on credits: 1 word consumes 1 credit, detection checks are free.
  • Use light intensity to preserve author voice and aggressive for strict detector environments.

Example use cases

  • Humanize an essay draft before submission to a university similarity check.
  • Rewrite marketing copy to sound more conversational and evade automated patterning.
  • Adjust AI-written technical documentation to match a team’s tone while lowering detector signals.
  • Prepare content for publications that flag high AI-generation scores.
  • Batch-process student assignments with credit-aware transformations and score reporting.

FAQ

What intensity should I choose by default?

Use medium for most cases; light preserves voice, aggressive maximizes detector bypassing when needed.

How are credits counted and shown?

Credits equal word count (1 word = 1 credit). The skill reports words processed and remaining credits after each run, and links to the dashboard to top up.

What happens if I run out of credits or have an invalid key?

If credits are insufficient, the skill shows required vs available credits and links to top up. If the API key is invalid, it prompts checking the HUMANIZERAI_API_KEY and directs you to obtain a valid key.