What Is the Output of Humanizer in Embedded Mode?

In embedded mode, Humanizer returns only the final rewritten text with all auxiliary information suppressed.

Humanizer is an AI‑text‑editing skill that rewrites machine‑generated prose into natural, human‑sounding language. When invoked in embedded mode, it strips away metadata such as detected patterns, drafting steps, and explanatory summaries—producing clean output ready for downstream consumption. This mode is designed specifically for automation pipelines where another task needs the edited text alone.

How Embedded Mode Works

According to the SKILL.md definition in the blader/humanizer repository, embedded mode serves "when another task uses this skill for a pull request, commit message, or document." The skill definition explicitly states: "return only the final text." This makes embedded mode distinct from the default pasted text mode (which includes formatting and context) and file mode (which writes to disk).

The embedded mode behavior is defined at line 52 of SKILL.md, where the three output styles are documented:

• Pasted text (default): Returns formatted output with surrounding context
• File mode: Writes the result to a specified file path
• Embedded mode: Returns only the final edited text as plain prose

Invoking Embedded Mode: Three Methods

The repository provides three entry points that support embedded mode activation.

OpenAI‑Compatible Agent Configuration

The agents/openai.yaml file implements conditional output based on the embedded flag:

name: humanizer
description: Rewrite AI‑sounding text.
prompt: |
  {{#if embedded}}
  {{humanized_text}}
  {{else}}
  {{default_output}}
  {{/if}}

When embedded is set to true, the template renders only {{humanized_text}}—the final rewrite with no wrapper content.

Claude Plugin Manifest

The .claude-plugin/plugin.json file exposes embedded mode through an option parameter:

{
  "name": "humanizer",
  "description": "Humanizer skill",
  "entrypoint": "SKILL.md",
  "options": {
    "mode": "embedded"
  }
}

Setting "mode": "embedded" configures the Claude plugin to emit the cleaned, final text directly.

Programmatic Invocation

The scripts/validate-package.py file demonstrates loading and calling the skill with mode selection:

from humanizer import Humanizer

skill = Humanizer()
result = skill.apply(text, mode="embedded")
print(result)          # <-- prints only the edited text

The mode="embedded" keyword argument triggers the suppression logic, ensuring result contains exactly the rewritten string.

What Gets Suppressed in Embedded Mode

To understand the value of embedded mode, consider what is excluded from the output:

Element	Default Mode	Embedded Mode
Final edited text	✅ Included	✅ Included
Detected AI patterns list	✅ Included	❌ Suppressed
Step‑by‑step drafting notes	✅ Included	❌ Suppressed
Explanatory summary	✅ Included	❌ Suppressed
Formatting markers	✅ Included	❌ Suppressed

This makes embedded mode ideal for composable workflows where Humanizer's output becomes input to another system—such as populating pull request templates, generating commit messages, or feeding into documentation generators.

When to Use Embedded Mode

Choose embedded mode in these scenarios:

• Pull request automation: Injecting humanized descriptions into GitHub PR templates
• Commit message generation: Producing clean messages for git commit
• Documentation pipelines: Embedding rewritten text into larger markdown files
• API responses: Returning processed text to calling services without wrapper content

Avoid embedded mode when you need visibility into why changes were made or when debugging the rewriting process.

Summary

• Embedded mode output: Only the final, rewritten plain text
• Key source file: SKILL.md defines the behavior at line 52
• Activation methods: agents/openai.yaml flag, .claude-plugin/plugin.json option, or mode="embedded" in Python
• Use case: Integration with downstream automation tasks requiring clean prose

Frequently Asked Questions

Does embedded mode affect how Humanizer rewrites the text?

No. The rewriting logic remains identical across all modes. Embedded mode only changes what is returned—suppressing metadata, not altering the text transformation itself.

Can I switch modes without modifying configuration files?

Yes. When using the Python API directly, pass mode="embedded" to skill.apply(). For agent configurations, set the embedded template variable to true at invocation time.

Is embedded mode the same as file mode?

No. File mode writes output to a specified path on disk and may include metadata in a header. Embedded mode returns only the final text to the caller, with no file I/O or additional structure.

What happens if I call Humanizer without specifying a mode?

The skill defaults to pasted text mode, which includes formatting, detected patterns, and explanatory context surrounding the final rewrite.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}