# What Is the Purpose of the Embedded Mode in Humanizer?

> Discover the purpose of Humanizer's embedded mode. Streamline CI/CD and workflows by getting only rewritten text, ideal for automated integration.

- Repository: [Siqi Chen/humanizer](https://github.com/blader/humanizer)
- Tags: how-to-guide
- Published: 2026-09-09

---

**The embedded mode in Humanizer returns only the final rewritten text without intermediate drafts or critiques, enabling seamless integration into automated CI/CD pipelines and programmatic workflows.**

The blader/humanizer repository provides a text refinement skill that supports three distinct output formats. While the default *pasted text* mode targets interactive users, and *file mode* handles bulk document processing, the **embedded mode** is architected specifically for machine-to-machine communication. This mode eliminates auxiliary output to deliver clean, parseable text that automated tools can consume directly.

## How Embedded Mode Works in Humanizer

According to the source code in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), embedded mode activates when another automated task invokes the skill—such as a pull-request reviewer or commit-message generator. In this state, Humanizer **returns only the final, human-written text** and strips away the intermediate draft, critique, and any analytical commentary that appears in interactive sessions.

The architectural design reflects a clear separation between human-centric interfaces and programmatic pipelines. By suppressing verbose output, embedded mode minimizes payload size and eliminates the need for downstream parsers to extract relevant content from surrounding metadata.

## Comparing Humanizer Output Modes

Humanizer supports three operational modes:

- **Pasted text (default)**: Provides the full rewrite workflow including drafts and critiques for human review.
- **File mode**: Processes entire documents while maintaining internal analysis accessible to the user.
- **Embedded mode**: Returns the finalized text only, optimized for automated consumption in CI/CD environments.

This distinction ensures that automated systems receive clean data without the bandwidth overhead or parsing complexity associated with interactive output.

## Implementing Embedded Mode in Automated Workflows

You can trigger embedded mode by setting the `HUMANIZER_MODE` environment variable to `embedded` before invoking the skill. This signals the interpreter to use the compact output format defined at line 52 of [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md).

### Automating Changelog Updates in GitHub Actions

The following workflow demonstrates embedded mode within a CI pipeline:

```yaml

# .github/workflows/humanize.yml

name: Humanize Changelog
on:
  push:
    branches: [main]

jobs:
  humanize:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install Humanizer
        run: npx skills add blader/humanizer --global
      - name: Humanize changelog entry (embedded mode)
        env:
          HUMANIZER_MODE: embedded
        run: |
          echo "/humanizer" > input.txt
          cat CHANGELOG.md >> input.txt
          /humanizer < input.txt > humanized.txt
      - name: Commit rewritten changelog
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add humanized.txt
          git commit -m "Update changelog – humanized"
          git push

```

### Streamlining Commit Message Generation

For local git hooks or shell scripts, embedded mode simplifies the extraction of polished commit messages:

```bash
#!/usr/bin/env bash

# generate-commit.sh

RAW_SUMMARY=$(git log -1 --pretty=%B)
export HUMANIZER_MODE=embedded
FINAL_MESSAGE=$(echo "$RAW_SUMMARY" | /humanizer)
git commit -am "$FINAL_MESSAGE"

```

Both examples leverage the minimal payload characteristic of embedded mode to insert results directly into version control without manual cleanup.

## Summary

- The **embedded mode in Humanizer** is defined in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md) and designed specifically for automated programmatic usage.
- When `HUMANIZER_MODE=embedded` is set, the skill returns only finalized text, omitting drafts and critiques.
- This mode eliminates parsing overhead for downstream tools and reduces bandwidth in CI/CD pipelines.
- Embedded mode contrasts with interactive modes by providing machine-readable output suitable for pull-request reviewers and commit-message generators.

## Frequently Asked Questions

### What is the embedded mode in Humanizer?

The embedded mode is a specialized output format in the blader/humanizer skill that returns only the final rewritten text without intermediate drafts or analytical commentary. According to the source code in [`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md), this mode activates when automated tasks such as pull-request reviewers or commit-message generators invoke the tool programmatically.

### How do I enable embedded mode in Humanizer?

Set the environment variable `HUMANIZER_MODE` to `embedded` before executing the skill. This configuration signals Humanizer to suppress auxiliary output and return the compact payload defined in the skill's prompt definition.

### What output does embedded mode produce compared to standard mode?

In standard pasted text mode, Humanizer provides the full workflow including drafts, critiques, and analysis for human review. In embedded mode, the tool returns **only the final, human-written text**, making the output immediately usable by downstream automation without requiring text extraction or parsing logic.

### Which Humanizer source file defines the embedded mode behavior?

The behavior is explicitly defined in **[`SKILL.md`](https://github.com/blader/humanizer/blob/main/SKILL.md)** at line 52, which specifies that when another task uses the skill for a pull request, commit message, or document processing, the system should "return only the final text."