Humanizer Embedded Mode for Pull Requests and Commit Messages: Automated Rewriting Guide

Humanizer's embedded mode automatically returns only the final rewritten text when invoked by automated tools, making it ideal for CI pipelines and bot integrations that need clean output without commentary or intermediate steps.

Humanizer is a pure-Markdown skill in the blader/humanizer repository that transforms technical text into human-friendly prose. When operating in embedded mode, the skill acts as a background processor that accepts raw pull request descriptions or commit messages and returns optimized text ready for immediate insertion. This guide explains the technical implementation of embedded mode for automated workflows.

What Is Humanizer's Embedded Mode?

Humanizer supports three distinct invocation methods: pasted text (default), file mode, and embedded mode. The embedded mode activates automatically when another task—such as a CI step, pull-request automation bot, or commit-message generator—calls the Humanizer skill programmatically. Unlike the interactive default mode, embedded mode suppresses all explanatory sections and returns exclusively the final humanized content.

Automatic Activation Context

The skill detects embedded mode based solely on the invocation context rather than explicit flags. When a host application or parent agent triggers Humanizer as a sub-task within a workflow, the operation automatically switches to embedded output. As documented in SKILL.md at line 52, the mode instruction states: "When another task uses this skill for a pull request, commit message, or document, return only the final text."

Output Comparison

Default mode provides verbose feedback including draft rewrites, pattern-check lists, and explanatory commentary. Embedded mode strips every intermediate artifact, emitting just the rewritten prose. This compact output eliminates parsing overhead for downstream automation, allowing direct piping into GitHub CLI commands or JSON response fields.

How Embedded Mode Processes Pull Requests and Commit Messages

When invoked in embedded mode, Humanizer applies its full suite of 25 rewrite patterns to the input text. The host environment interprets the programmatic context and suppresses auxiliary sections before returning the result to the caller.

The Four-Step Integration Flow

1. Caller Transmission — A GitHub Action, Claude-based bot, or automation script transmits the raw PR description or commit message to the Humanizer skill.
2. Pattern Application — Humanizer processes the text through its 25 rewrite patterns to eliminate jargon and improve readability.
3. Contextual Filtering — Embedded mode filters the output, retaining only the final edited text without metadata.
4. Direct Injection — The caller receives the cleaned string and writes it back to the PR body or commit message store.

Because Humanizer contains no executable code for mode toggling, this behavior relies entirely on the host's interpretation of the call context. The skill itself remains a static Markdown document; the environment determines which sections to render.

Integration Patterns for Embedded Mode

The following implementations demonstrate how to leverage embedded mode in common automation scenarios. In each case, the skill recognizes the programmatic context and returns pipe-ready text.

CI Pipeline Integration with Skills CLI

When running Humanizer within a CI script, embedded mode activates because the output captures into a shell variable. The following example installs the skill and rewrites a pull request description:

# Install Humanizer globally

npx skills add blader/humanizer --global

# Assume $PR_BODY contains the raw pull-request description

# Humanizer returns only the final text because the call is

# part of a script expecting a plain string

humanized=$(echo "$PR_BODY" | npx skills run humanizer)

# Update the PR via the GitHub CLI

gh pr edit $PR_NUMBER --body "$humanized"

JSON API Calls for Claude-Compatible Agents

Claude-compatible agents can invoke Humanizer via structured JSON requests. When the context field indicates a commit-message use case, the host runs the skill in embedded mode:

{
  "skill": "humanizer",
  "input": "Fix typo in the API endpoint – remove the trailing slash.",
  "context": "commit-message"
}

The response returns as a single raw string without JSON wrapper objects or markdown code blocks:

Fix typo in the API endpoint: remove the trailing slash.

Claude-Code Plugin Integration

Within a Claude-Code session, the plugin invocation triggers embedded mode automatically because the request originates from another task:

# Inside a Claude-Code session

/humanizer:humanizer

# Paste the raw PR description

The skill returns only the final edited block, ready for immediate copying back into the pull request interface.

Core Source Files

The embedded mode functionality is defined entirely within the repository's documentation structure:

• SKILL.md — Contains the core skill definition, including the embedded-mode description at line 52 and the complete set of 25 rewrite patterns.
• README.md — Provides user-facing documentation covering installation procedures, usage mode comparisons, and integration examples.
• .claude-plugin/plugin.json — Serves as the plugin manifest for Claude-compatible agents, pointing to the skill root and enabling automatic discovery.

Summary

• Automatic Activation — Embedded mode triggers when another task programmatically calls the Humanizer skill, requiring no explicit configuration flags.
• Minimal Output — The mode returns exclusively final rewritten text, omitting draft versions, pattern-check lists, and explanatory commentary.
• Pipeline Ready — Clean string output enables direct piping into GitHub CLI, JSON APIs, and other automation tools without parsing overhead.
• Pure Markdown Architecture — Mode selection occurs through host interpretation of call context rather than executable code, as defined in SKILL.md.

Frequently Asked Questions

How does embedded mode differ from Humanizer's default mode?

Default mode provides interactive, verbose output including draft rewrites and pattern explanations suitable for manual review. Embedded mode returns only the final humanized text string, making it optimal for automated pipelines that require clean input for subsequent processing steps.

Can I force embedded mode when testing locally?

No. Because Humanizer is a pure-Markdown skill without executable code, mode selection depends entirely on the host environment's interpretation of the call context. When you run the skill directly in a terminal for testing, it operates in default pasted-text mode; embedded mode activates only when another automated task or agent invokes the skill as a sub-process.

What happens to the 25 rewrite patterns in embedded mode?

All 25 rewrite patterns execute normally during text processing in embedded mode. The difference lies in output formatting: while the patterns analyze and transform the input text fully, embedded mode suppresses the intermediate pattern-check list and draft commentary, emitting only the final result.

Which file contains the embedded mode behavior definition?

The embedded mode instruction resides in SKILL.md at line 52, which states: "When another task uses this skill for a pull request, commit message, or document, return only the final text." This file also houses all rewrite patterns and operational logic for the skill.

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