DEV Community: UnAIMyText

Humanize OpenAI Chat Completions in Swift: An App Store What's New Linter + 5 Free Tools (2026)

UnAIMyText — Fri, 06 Nov 2026 20:56:17 +0000

Compiled and verified on 2026-11-06. Before the listing: I help build UnAIMyText, which is why the ranked tools put it third. The Swift sources are yours to reuse.

App Store "What's New" on our iOS build started reading like a WWDC bumper. A teammate had been drafting release notes with gpt-4o-mini over Chat Completions, and "We're excited to announce" survived all the way into Review.

That tone is noise in the Updates tab. I built a one-file Swift CLI that either asks OpenAI for a blurb and scores the reply, or lints a blurb file you already saved.

What it checks

These rules catch the leftover machine voice that sneaks into short release notes:

Character budget. What's New stays ≤280 characters for a phone-sized skim.
Assistant throat-clearing. Drop drafts that open with Here is / Sure / Certainly / Of course.
Markdown leftovers. Drop drafts that still contain a fenced code block.
Label leftovers. Drop drafts that begin with Title: / What's New: / Update:.
Corporate leftovers. Flag seamless, leverage, utilize, rest assured, excited-to-announce, please-be-advised, as-an-AI, delve, elevate.
All-caps tokens. Any word with five or more capitals fails.
Bang / emoji spam. Two or more exclamation marks, or two or more emoji, fails.

Exit 0 means ship it, exit 1 means rewrite, exit 2 means the HTTP call or the file path failed. Pass --json when a script needs the problem list.

What the OpenAI docs say

I keyed the client to OpenAI's Chat Completions reference (POST /v1/chat/completions). The bits that mattered for this file:

Send Authorization: Bearer <OPENAI_API_KEY> plus Content-Type: application/json.
Body minimums are model and a messages array of {role, content} objects. A modest max_tokens keeps a runaway draft from eating the budget.
The assistant text lives at choices[].message.content on a chat.completion object. Non-2xx responses become exit 2.
Override OPENAI_BASE_URL to aim at the local mock (or any proxy) without changing the path.

The code

Works on Linux or macOS. No Package Manager dance for the happy path — one swiftc invocation is enough.

// ReleaseLint: draft an App Store "What's New" blurb with OpenAI Chat Completions, or lint one.
//   swiftc -O ReleaseLint.swift -o ReleaseLint
//   ./ReleaseLint --draft "faster cold start, share sheet crash fix, offline drafts"
//   ./ReleaseLint samples/robotic.txt
// Return 0 on clean copy, 1 when a rewrite is needed, 2 when the call or input failed.
// Swift / Foundation only (URLSession). No third-party packages.

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

struct Problem: Codable {
    let id: String
    let problem: String
}

let maxChars = 280

func die(_ msg: String) -> Never {
    fputs("releaselint: \(msg)\n", stderr)
    exit(2)
}

func fencePattern() -> NSRegularExpression {
    // Build fence opener without a literal triple-backtick string in source.
    let opener = String(repeating: "`", count: 3)
    return try! NSRegularExpression(pattern: "^\\s*" + NSRegularExpression.escapedPattern(for: opener), options: .anchorsMatchLines)
}

let preamble = try! NSRegularExpression(
    pattern: "^\\s*(here('s| is| are)|sure|certainly|of course|gladly)\\b",
    options: .caseInsensitive
)
let filler = try! NSRegularExpression(
    pattern: "\\b(seamless(ly)?|leverage|utilize|rest assured|we're excited to announce|" +
        "please be advised|at this time|going forward|in order to|as an ai|" +
        "delve|elevate|unlock|game[- ]changer|synergy|holistic)\\b",
    options: .caseInsensitive
)
let shouting = try! NSRegularExpression(pattern: "\\b[A-Z]{5,}\\b", options: [])
let label = try! NSRegularExpression(
    pattern: "^\\s*(title|summary|status|update|blurb|what's new)\\s*:",
    options: [.caseInsensitive, .anchorsMatchLines]
)

func lintText(id: String, raw: String) -> [Problem] {
    var p: [Problem] = []
    let t = raw.trimmingCharacters(in: .whitespacesAndNewlines)
    if t.isEmpty {
        return [Problem(id: id, problem: "empty blurb")]
    }
    if t.count > maxChars {
        p.append(Problem(id: id, problem: "blurb is \(t.count) chars (keep it to \(maxChars))"))
    }
    let range = NSRange(t.startIndex..., in: t)
    if preamble.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "model preamble (Here is / Sure / Certainly)"))
    }
    if fencePattern().firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "code fence left in the draft"))
    }
    if label.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "pasted Title:/What's New: label"))
    }
    if filler.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "robotic filler phrase"))
    }
    if shouting.firstMatch(in: t, options: [], range: range) != nil {
        p.append(Problem(id: id, problem: "shouting (5+ letter capitals)"))
    }
    let bangs = t.filter { $0 == "!" }.count
    if bangs > 1 {
        p.append(Problem(id: id, problem: "stacked exclamation marks (\(bangs))"))
    }
    let emoji = t.unicodeScalars.filter { s in
        let v = s.value
        return (0x1F300...0x1FAFF).contains(v) || (0x2600...0x27BF).contains(v) || (0x1F1E6...0x1F1FF).contains(v)
    }.count
    if emoji > 1 {
        p.append(Problem(id: id, problem: "more than one emoji (\(emoji))"))
    }
    return p
}

func jsonEscape(_ s: String) -> String {
    var b = "\""
    for c in s.unicodeScalars {
        switch c {
        case "\\": b += "\\\\"
        case "\"": b += "\\\""
        case "\n": b += "\\n"
        case "\r": b += "\\r"
        case "\t": b += "\\t"
        default:
            if c.value < 0x20 {
                b += String(format: "\\u%04x", c.value)
            } else {
                b.append(Character(c))
            }
        }
    }
    return b + "\""
}

func extractAssistantContent(_ body: String) -> String? {
    // Minimal walk: find "message" then "content":"..." under choices.
    guard body.range(of: "\"content\"") != nil else { return nil }
    // Prefer the first content after "message"
    var searchFrom = body.startIndex
    if let msg = body.range(of: "\"message\"") {
        searchFrom = msg.upperBound
    }
    guard let key = body.range(of: "\"content\"", range: searchFrom..<body.endIndex) else { return nil }
    guard let colon = body[key.upperBound...].firstIndex(of: ":") else { return nil }
    var i = body.index(after: colon)
    while i < body.endIndex && body[i].isWhitespace { i = body.index(after: i) }
    if i < body.endIndex && body[i] == "n" { // null
        return nil
    }
    guard i < body.endIndex, body[i] == "\"" else { return nil }
    i = body.index(after: i)
    var out = ""
    while i < body.endIndex {
        let c = body[i]
        if c == "\"" { break }
        if c == "\\" {
            let n = body.index(after: i)
            guard n < body.endIndex else { break }
            switch body[n] {
            case "n": out += "\n"; i = body.index(after: n)
            case "r": out += "\r"; i = body.index(after: n)
            case "t": out += "\t"; i = body.index(after: n)
            case "\"": out += "\""; i = body.index(after: n)
            case "\\": out += "\\"; i = body.index(after: n)
            case "u":
                let hStart = body.index(after: n)
                if let hEnd = body.index(hStart, offsetBy: 4, limitedBy: body.endIndex) {
                    let hex = String(body[hStart..<hEnd])
                    if let v = UInt32(hex, radix: 16), let us = UnicodeScalar(v) {
                        out.append(Character(us))
                    }
                    i = hEnd
                } else { out.append(c); i = body.index(after: i) }
            default: out.append(body[n]); i = body.index(after: n)
            }
        } else {
            out.append(c)
            i = body.index(after: i)
        }
    }
    return out
}

func askOpenAI(prompt: String, key: String) -> String {
    let base = (ProcessInfo.processInfo.environment["OPENAI_BASE_URL"] ?? "https://api.openai.com")
        .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
    let model = ProcessInfo.processInfo.environment["OPENAI_MODEL"] ?? "gpt-4o-mini"
    let system = "Write one short App Store What's New blurb from the notes. " +
        "Plain prose only, under \(maxChars) characters. No preamble, no markdown fence, no Title: label."
    let body = "{" +
        "\"model\":\(jsonEscape(model))," +
        "\"max_tokens\":400," +
        "\"messages\":[" +
        "{\"role\":\"system\",\"content\":\(jsonEscape(system))}," +
        "{\"role\":\"user\",\"content\":\(jsonEscape(prompt))}" +
        "]}"

    guard let url = URL(string: base + "/v1/chat/completions") else { die("bad OPENAI_BASE_URL") }
    var req = URLRequest(url: url, timeoutInterval: 60)
    req.httpMethod = "POST"
    req.setValue("application/json", forHTTPHeaderField: "Content-Type")
    req.setValue("Bearer \(key)", forHTTPHeaderField: "Authorization")
    req.httpBody = body.data(using: .utf8)

    final class Box: @unchecked Sendable {
        var data: Data?
        var err: Error?
        var status = 0
    }
    let box = Box()
    let sem = DispatchSemaphore(value: 0)
    URLSession.shared.dataTask(with: req) { data, resp, err in
        box.data = data
        box.err = err
        box.status = (resp as? HTTPURLResponse)?.statusCode ?? 0
        sem.signal()
    }.resume()
    _ = sem.wait(timeout: .now() + 65)

    if let resultErr = box.err { die("request failed: \(resultErr.localizedDescription)") }
    guard let data = box.data, let text = String(data: data, encoding: .utf8) else {
        die("empty reply")
    }
    if box.status / 100 != 2 {
        let snip = String(text.prefix(200))
        die("HTTP \(box.status): \(snip)")
    }
    guard let content = extractAssistantContent(text), !content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
        die("reply had no assistant content")
    }
    return content
}

func report(_ problems: [Problem], asJson: Bool) {
    if asJson {
        let enc = JSONEncoder()
        if let data = try? enc.encode(problems), let s = String(data: data, encoding: .utf8) {
            print(s)
        } else {
            print("[]")
        }
    } else {
        for p in problems { print("\(p.id): \(p.problem)") }
        if problems.isEmpty { print("ok") }
    }
}

var args = Array(CommandLine.arguments.dropFirst())
let asJson = args.contains("--json")
args.removeAll { $0 == "--json" }
if args.isEmpty { die("usage: --draft \"notes\" | path/to/blurb.txt [--json]") }

let problems: [Problem]
if args[0] == "--draft" {
    let prompt = args.dropFirst().joined(separator: " ").trimmingCharacters(in: .whitespacesAndNewlines)
    if prompt.isEmpty { die("missing draft notes after --draft") }
    guard let key = ProcessInfo.processInfo.environment["OPENAI_API_KEY"], !key.isEmpty else {
        die("set OPENAI_API_KEY")
    }
    let draft = askOpenAI(prompt: prompt, key: key)
    print("--- draft ---")
    print(draft)
    print("-------------")
    problems = lintText(id: "draft", raw: draft)
} else {
    let path = args[0]
    guard FileManager.default.fileExists(atPath: path) else { die("missing file: \(path)") }
    guard let text = try? String(contentsOfFile: path, encoding: .utf8) else {
        die("cannot read \(path)")
    }
    let name = URL(fileURLWithPath: path).lastPathComponent
    problems = lintText(id: name, raw: text)
}
report(problems, asJson: asJson)
exit(problems.isEmpty ? 0 : 1)

Implementation notes: the fence detector joins three backtick characters at runtime so the .swift file never stores a literal triple-backtick string. The reply walker only hunts the first content string after message, which matches the Chat Completions shape we need without pulling in a JSON package. On Linux, pull in FoundationNetworking when your SDK splits networking away from Foundation.

A mock Chat Completions endpoint

Credits stay in the wallet because tests hit a tiny Python http.server fake. It speaks Chat Completions JSON, offers five canned modes, and prints one diagnostic line per POST.

#!/usr/bin/env python3
# Fake api.openai.com /v1/chat/completions for tests.
#   python3 mock_openai.py [robotic|clean|error|empty|prose] [port]
import json, sys
from http.server import BaseHTTPRequestHandler, HTTPServer

MODE = sys.argv[1] if len(sys.argv) > 1 else "robotic"
PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 8788
FENCE = "`" * 3
REPLIES = {
    "robotic": (
        "Sure! Here is a What's New blurb:\n"
        + FENCE + "\n"
        "We're excited to announce a seamless onboarding experience. "
        "REST ASSURED we leverage AI to elevate your workflow!!!\n"
        + FENCE
    ),
    "clean": (
        "What's New in 2.4: faster cold-start on iPhone 15, a fix for the "
        "share-sheet crash on iPad, and offline drafts that sync when you're back online."
    ),
    "empty": "",
    "prose": "Certainly, the release notes have been prepared for App Store review.",
}

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        length = int(self.headers.get("Content-Length", "0"))
        body = self.rfile.read(length).decode("utf-8")
        try:
            payload = json.loads(body)
        except Exception:
            payload = {}
        auth = self.headers.get("Authorization", "")
        has_bearer = auth.startswith("Bearer ") and len(auth) > 7
        has_model = "\"model\"" in body or "model" in payload
        has_max = "max_tokens" in body or "max_completion_tokens" in body
        has_msgs = "messages" in payload
        print(
            f"path={self.path} auth={'yes' if has_bearer else 'no'} "
            f"model={has_model} max_tokens={has_max} messages={has_msgs}",
            flush=True,
        )
        if MODE == "error":
            status, out = 400, {
                "error": {"message": "invalid model", "type": "invalid_request_error"}
            }
        else:
            text = REPLIES.get(MODE, REPLIES["clean"])
            status, out = 200, {
                "id": "chatcmpl_test",
                "object": "chat.completion",
                "choices": [
                    {
                        "index": 0,
                        "message": {"role": "assistant", "content": text},
                        "finish_reason": "stop",
                    }
                ],
            }
        data = json.dumps(out).encode()
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def log_message(self, *args):
        pass

if __name__ == "__main__":
    print(f"mock listening on {PORT} mode={MODE}", flush=True)
    HTTPServer(("127.0.0.1", PORT), Handler).serve_forever()

Running it

export PATH=/path/to/swift/usr/bin:$PATH
# On some Linux boxes you also need libncurses.so.6 on LD_LIBRARY_PATH
swiftc -O ReleaseLint.swift -o ReleaseLint

# lint a blurb file
./ReleaseLint samples/clean.txt

# ask OpenAI for a draft, then lint it
export OPENAI_API_KEY=sk-...
./ReleaseLint --draft "faster cold start, share sheet crash fix, offline drafts"

# point it at the mock
python3 mock_openai.py robotic 8788 &
OPENAI_API_KEY=sk-test OPENAI_BASE_URL=http://127.0.0.1:8788 \
  ./ReleaseLint --draft "faster cold start, share sheet crash fix"

Test results

Test results (2026-11-06, Swift 6.0.3 on Linux x86_64)

Installed under /workspace/tools/swift-6.0.3-RELEASE-ubuntu22.04. LD_LIBRARY_PATH includes /workspace/tools/ruby32/lib so libncurses.so.6 resolves. Compile line: swiftc -O ReleaseLint.swift -o build/ReleaseLint. The stand-in API is mock_openai.py.

Observed exits:

robotic sample file → 1 (preamble + fence + filler + shouting + bangs)
clean sample file → 0
long sample with --json → 1 (397 characters over the 280 cap, plus filler)
samples/broken.json fed as text → 0 (lint path does not parse JSON)
missing path → 2
zero arguments → 2
mock mode robotic → 1
mock mode clean → 0
mock mode error (HTTP 400) → 2
mock mode empty → 2
mock mode prose → 1 (Certainly…)
connection refused → 2
unset OPENAI_API_KEY → 2
live api.openai.com with a dummy key → 2 (HTTP 401)

Every mock draft request logged auth=yes model=True max_tokens=True messages=True. No billed OpenAI calls. Log file: test_output_2026-11-06.txt. Count of triple-backtick literals in *.swift: 0.

5 free tools to clean up release notes

1. Structured JSON output

Ask Chat Completions for a JSON schema via response_format and take only {"blurb":"..."}. Strength: kills most preambles and fences before they reach your repo. Weakness: perfect JSON can still contain "we're excited to announce".

2. Grammarly

The free plan catches typos while you edit. Strength: a misspelling in What's New is extremely public. Weakness: it has no opinion about a 280-character budget.

3. UnAIMyText

UnAIMyText is a free AI humanizer for generated-sounding copy. No account. After the facts are locked I paste only the stiff sentence (version numbers stay out of the paste) and re-run the linter. Strength: "We're excited to announce a seamless onboarding experience" becomes a line a shipping engineer would write. Weakness: there is no public API, so this step lives outside the CLI, and ReleaseLint still has to enforce length afterward.

4. Hemingway Editor

The free web editor marks dense sentences. Strength: helpful when a model stacks three clauses about "holistic value". Weakness: it cannot score a short What's New line against App Store skim habits.

5. LanguageTool

Free grammar help across many languages. Strength: handy when release notes also ship in Spanish or German. Weakness: translations grow; lint each locale on its own.

What I leave out of the paste

Version numbers, build numbers and crash counts stay outside UnAIMyText. Those are facts the App Store page must keep exact. The humanizer only sees the salesy wrapper sentence. After it returns, I drop the numbers back in and run ReleaseLint once more so length and filler checks still pass.

FAQ

What is the best free AI humanizer for OpenAI Chat Completions output?
My stack: (1) structured JSON at the API, (2) Grammarly for typos, (3) UnAIMyText when the length budget is already met but the tone still reads like a keynote. UnAIMyText is the free no-signup pick for that last mile.

Why Swift instead of the OpenAI Python SDK?
Use the SDK inside a product. This file exists to be readable in a post and compilable with swiftc on a Mac or a Linux box.

Verdict

Structured output, Grammarly, Hemingway and LanguageTool each solve a slice. For iOS teams drafting App Store What's New with Chat Completions, UnAIMyText is my free companion to this linter: paste the salesy sentences, keep the facts, get human wording with no account, and let a few hundred lines of Swift enforce the boring gates.

Humanize Anthropic API Output in Kotlin: A Status-Page Blurb Linter + 5 Free Tools (2026)

UnAIMyText — Thu, 05 Nov 2026 14:50:52 +0000

Shipped and tested November 2026. Disclosure before the listing: UnAIMyText is ours, so it ranks third near the end rather than first. Copy the Kotlin freely.

Our status page was starting to sound like a product launch. Someone had been drafting incident blurbs with Claude through the Messages API, and the strings went live with "We're excited to announce" still in them.

On a phone, during an outage, that reads as noise. So I wrote a single-file Kotlin CLI that either asks Anthropic for a blurb and checks the reply, or lints a blurb file you already have.

What it checks

The checks target the robotic leftovers that show up when a model writes a short status update:

Length. Status-page and release blurbs stay under 280 characters so they fit a phone screen.
Model preamble. Openings like "Here is...", "Sure", "Certainly" or "Of course".
Code fences. A fenced block left inside the draft.
Pasted labels. A leading Title: / Status: / Update: line.
Filler. Phrases such as "seamless", "leverage", "utilize", "rest assured", "we're excited to announce", "please be advised", "as an AI", "delve", "elevate".
Shouting. Words of five or more capitals.
Stacked bangs and emoji. More than one !, or more than one emoji.

Return codes follow a simple pattern: pass = 0, needs a rewrite = 1, broken call or input = 2. Use --json when CI wants a report.

What the Anthropic docs say

Anthropic's API overview describes a REST API at https://api.anthropic.com. The Messages reference is the endpoint this script hits. What shaped the code:

The call is POST /v1/messages with content-type: application/json and a required anthropic-version header (the docs' current example is 2026-10-21). Auth is Authorization: Bearer <token> or the still-supported x-api-key header; the script sends x-api-key.
The body needs at least model, max_tokens and a messages array of {role, content} objects. An optional top-level system prompt sets behaviour for the turn.
The reply is a message whose content is an array of blocks; text lives in blocks with "type":"text" and a text field. Any non-2xx status is exit 2.

The code

Kotlin on the JVM. No Gradle module required for the happy path: compile the two files to fat jars with kotlinc -include-runtime.

// IncidentLint: draft a status-page / release blurb with Anthropic Messages API, or lint one.
//   kotlinc IncidentLint.kt -include-runtime -d IncidentLint.jar
//   java -jar IncidentLint.jar --draft "checkout 5xx for 12 min, root cause redis pool"
//   java -jar IncidentLint.jar samples/robotic.txt
// Return 0 on a clean blurb, 1 when a rewrite is needed, 2 when the call or input failed.
// Kotlin/JVM; java.net.http + kotlin stdlib only.

import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.nio.charset.StandardCharsets
import java.nio.file.Files
import java.nio.file.Path
import java.time.Duration
import java.util.regex.Pattern

data class Problem(val id: String, val msg: String) {
    fun toJson(): String = """{"id":${jsonQuote(id)},"problem":${jsonQuote(msg)}}"""
}

fun jsonQuote(s: String): String {
    val b = StringBuilder("\"")
    for (c in s) {
        when (c) {
            '\\' -> b.append("\\\\")
            '"' -> b.append("\\\"")
            '\n' -> b.append("\\n")
            '\r' -> b.append("\\r")
            '\t' -> b.append("\\t")
            else -> if (c.code < 0x20) b.append("\\u%04x".format(c.code)) else b.append(c)
        }
    }
    return b.append('"').toString()
}

fun die(msg: String): Nothing {
    System.err.println("incidentlint: $msg")
    kotlin.system.exitProcess(2)
}

val PREAMBLE: Pattern = Pattern.compile(
    "^\\s*(here('s| is| are)|sure|certainly|of course|gladly)\\b",
    Pattern.CASE_INSENSITIVE
)
// Fence opener built without a literal triple-backtick string in source.
val FENCE: Pattern = Pattern.compile("^\\s*" + Pattern.quote("`" + "`" + "`"), Pattern.MULTILINE)
val FILLER: Pattern = Pattern.compile(
    "\\b(seamless(ly)?|leverage|utilize|rest assured|we're excited to announce|" +
        "please be advised|at this time|going forward|in order to|as an ai|" +
        "delve|elevate|unlock|game[- ]changer|synergy|holistic)\\b",
    Pattern.CASE_INSENSITIVE
)
val SHOUTING: Pattern = Pattern.compile("\\b[A-Z]{5,}\\b")
val LABEL: Pattern = Pattern.compile(
    "^\\s*(title|summary|status|update|blurb)\\s*:",
    Pattern.CASE_INSENSITIVE
)

const val MAX_CHARS = 280 // short status-page / release blurb

fun lintText(id: String, raw: String): List<Problem> {
    val p = mutableListOf<Problem>()
    val t = raw.trim()
    if (t.isEmpty()) {
        p.add(Problem(id, "empty blurb"))
        return p
    }
    if (t.length > MAX_CHARS) p.add(Problem(id, "blurb is ${t.length} chars (keep it to $MAX_CHARS)"))
    if (PREAMBLE.matcher(t).find()) p.add(Problem(id, "model preamble (Here is / Sure / Certainly)"))
    if (FENCE.matcher(t).find()) p.add(Problem(id, "code fence left in the draft"))
    if (LABEL.matcher(t).find()) p.add(Problem(id, "pasted Title:/Status: label"))
    if (FILLER.matcher(t).find()) p.add(Problem(id, "robotic filler phrase"))
    if (SHOUTING.matcher(t).find()) p.add(Problem(id, "shouting (5+ letter capitals)"))
    val bangs = t.count { it == '!' }
    if (bangs > 1) p.add(Problem(id, "stacked exclamation marks ($bangs)"))
    val emoji = t.codePoints().filter { cp ->
        (cp in 0x1F300..0x1FAFF) || (cp in 0x2600..0x27BF) || (cp in 0x1F1E6..0x1F1FF)
    }.count().toInt()
    if (emoji > 1) p.add(Problem(id, "more than one emoji ($emoji)"))
    return p
}

fun extractTextBlocks(body: String): String {
    // Minimal parse: pull "type":"text" then "text":"..." values, in order.
    val out = StringBuilder()
    var i = 0
    while (true) {
        val typeIdx = body.indexOf("\"type\"", i)
        if (typeIdx < 0) break
        val afterType = body.indexOf(':', typeIdx)
        val q1 = body.indexOf('"', afterType + 1)
        val q2 = body.indexOf('"', q1 + 1)
        if (q1 < 0 || q2 < 0) break
        val typ = body.substring(q1 + 1, q2)
        if (typ == "text") {
            val textKey = body.indexOf("\"text\"", q2)
            if (textKey < 0) { i = q2 + 1; continue }
            val colon = body.indexOf(':', textKey)
            val start = body.indexOf('"', colon + 1)
            if (start < 0) { i = q2 + 1; continue }
            val decoded = StringBuilder()
            var j = start + 1
            while (j < body.length) {
                val c = body[j]
                if (c == '"') break
                if (c == '\\' && j + 1 < body.length) {
                    when (body[j + 1]) {
                        'n' -> { decoded.append('\n'); j += 2 }
                        'r' -> { decoded.append('\r'); j += 2 }
                        't' -> { decoded.append('\t'); j += 2 }
                        '"' -> { decoded.append('"'); j += 2 }
                        '\\' -> { decoded.append('\\'); j += 2 }
                        'u' -> {
                            if (j + 5 < body.length) {
                                val hex = body.substring(j + 2, j + 6)
                                decoded.append(hex.toInt(16).toChar())
                                j += 6
                            } else { decoded.append(c); j++ }
                        }
                        else -> { decoded.append(body[j + 1]); j += 2 }
                    }
                } else {
                    decoded.append(c); j++
                }
            }
            if (out.isNotEmpty()) out.append('\n')
            out.append(decoded)
            i = j + 1
        } else {
            i = q2 + 1
        }
    }
    return out.toString()
}

fun askAnthropic(prompt: String, key: String): String {
    val base = System.getenv("ANTHROPIC_BASE_URL") ?: "https://api.anthropic.com"
    val model = System.getenv("ANTHROPIC_MODEL") ?: "claude-haiku-4-5-20251001"
    val version = System.getenv("ANTHROPIC_VERSION") ?: "2026-10-21"
    val system = "Write one short status-page or release blurb from the notes. " +
        "Plain prose only, under $MAX_CHARS characters. No preamble, no markdown fence, no Title: label."
    val body = """{"model":${jsonQuote(model)},"max_tokens":400,"system":${jsonQuote(system)},"messages":[{"role":"user","content":${jsonQuote(prompt)}}]}"""

    val builder = HttpRequest.newBuilder(URI.create(base.trimEnd('/') + "/v1/messages"))
        .timeout(Duration.ofSeconds(60))
        .header("content-type", "application/json")
        .header("anthropic-version", version)
        .header("x-api-key", key)
        .POST(HttpRequest.BodyPublishers.ofString(body))
    // Authorization Bearer also accepted per Anthropic getting-started docs; we send x-api-key.
    val client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build()
    val res = try {
        client.send(builder.build(), HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8))
    } catch (e: Exception) {
        die("request failed: ${e.message}")
    }
    if (res.statusCode() / 100 != 2) {
        val snip = res.body().take(200)
        die("HTTP ${res.statusCode()}: $snip")
    }
    val text = extractTextBlocks(res.body())
    if (text.isBlank()) die("reply had no text content block")
    return text
}

fun report(problems: List<Problem>, asJson: Boolean) {
    if (asJson) {
        println("[" + problems.joinToString(",") { it.toJson() } + "]")
    } else {
        for (p in problems) println("${p.id}: ${p.msg}")
        if (problems.isEmpty()) println("ok")
    }
}

fun main(args: Array<String>) {
    val rest = args.toMutableList()
    val asJson = rest.remove("--json")
    if (rest.isEmpty()) die("usage: --draft \"notes\" | path/to/blurb.txt [--json]")

    val problems: List<Problem>
    if (rest[0] == "--draft") {
        val prompt = rest.drop(1).joinToString(" ").trim()
        if (prompt.isEmpty()) die("missing draft notes after --draft")
        val key = System.getenv("ANTHROPIC_API_KEY") ?: ""
        if (key.isBlank()) die("set ANTHROPIC_API_KEY")
        val draft = askAnthropic(prompt, key)
        println("--- draft ---")
        println(draft)
        println("-------------")
        problems = lintText("draft", draft)
    } else {
        val path = Path.of(rest[0])
        if (!Files.exists(path)) die("missing file: $path")
        val text = try {
            Files.readString(path)
        } catch (e: Exception) {
            die("cannot read $path: ${e.message}")
        }
        problems = lintText(path.fileName.toString(), text)
    }
    report(problems, asJson)
    when {
        problems.isEmpty() -> kotlin.system.exitProcess(0)
        else -> kotlin.system.exitProcess(1)
    }
}

Notes: the fence detector builds its pattern from three backtick characters joined at runtime, so the source never contains a literal triple-backtick string. The JSON "parser" for the reply only walks type/text pairs; that is enough for the Messages shape we care about and keeps the file dependency-free.

A mock Anthropic Messages endpoint

To test without spending credits, I wrote a short fake server on com.sun.net.httpserver.HttpServer. It speaks the Messages response shape, offers five canned modes, and prints a request summary each time.

// Fake api.anthropic.com /v1/messages for tests.
//   kotlinc -include-runtime -d MockAnthropic.jar MockAnthropic.kt
//   java -jar MockAnthropic.jar [robotic|clean|error|empty|prose] [port]
import com.sun.net.httpserver.HttpServer
import java.io.OutputStream
import java.net.InetSocketAddress
import java.nio.charset.StandardCharsets

fun main(args: Array<String>) {
    val mode = args.getOrElse(0) { "robotic" }
    val port = args.getOrElse(1) { "8788" }.toInt()
    val fence = "`" + "`" + "`"
    val replies = mapOf(
        "robotic" to "Sure! Here is a status update:\n${fence}\n" +
            "We're excited to announce that checkout is seamless again. REST ASSURED we leverage redis.\n$fence",
        "clean" to "Checkout returned 5xx for 12 minutes. Cause: redis pool exhaustion. Mitigated by raising the pool and failing open to cache.",
        "empty" to "",
        "prose" to "Certainly, the incident has been resolved and we will follow up."
    )
    val server = HttpServer.create(InetSocketAddress("127.0.0.1", port), 0)
    server.createContext("/v1/messages") { exch ->
        val body = exch.requestBody.readBytes().toString(StandardCharsets.UTF_8)
        val key = exch.requestHeaders.getFirst("x-api-key") ?: ""
        val ver = exch.requestHeaders.getFirst("anthropic-version") ?: ""
        val hasModel = body.contains("\"model\"")
        val hasMax = body.contains("\"max_tokens\"")
        val hasMsgs = body.contains("\"messages\"")
        println("path=${exch.requestURI.path} key=${if (key.isNotEmpty()) "yes" else "no"} " +
            "version=$ver model=$hasModel max_tokens=$hasMax messages=$hasMsgs")
        val ok = mode != "error"
        val reply = if (ok) {
            val text = replies[mode] ?: replies.getValue("clean")
            """{"id":"msg_test","type":"message","role":"assistant","model":"mock","content":[{"type":"text","text":${jsonQ(text)}}],"stop_reason":"end_turn"}"""
        } else {
            """{"type":"error","error":{"type":"invalid_request_error","message":"invalid model"}}"""
        }
        val bytes = reply.toByteArray(StandardCharsets.UTF_8)
        exch.responseHeaders.add("Content-Type", "application/json")
        exch.sendResponseHeaders(if (ok) 200 else 400, bytes.size.toLong())
        val os: OutputStream = exch.responseBody
        os.write(bytes)
        os.close()
    }
    server.executor = null
    server.start()
    println("mock listening on $port mode=$mode")
    Thread.currentThread().join()
}

fun jsonQ(s: String): String {
    val b = StringBuilder("\"")
    for (c in s) {
        when (c) {
            '\\' -> b.append("\\\\")
            '"' -> b.append("\\\"")
            '\n' -> b.append("\\n")
            '\r' -> b.append("\\r")
            '\t' -> b.append("\\t")
            else -> b.append(c)
        }
    }
    return b.append('"').toString()
}

Running it

export JAVA_HOME=/path/to/jdk17
export PATH="$JAVA_HOME/bin:/path/to/kotlinc/bin:$PATH"
kotlinc IncidentLint.kt -include-runtime -d IncidentLint.jar
kotlinc MockAnthropic.kt -include-runtime -d MockAnthropic.jar

# lint a blurb file
java -jar IncidentLint.jar samples/clean.txt

# ask Anthropic for a draft, then lint it
export ANTHROPIC_API_KEY=sk-ant-...
java -jar IncidentLint.jar --draft "checkout 5xx for 12 min, root cause redis pool"

# point it at the mock
java -jar MockAnthropic.jar robotic 8788 &
ANTHROPIC_API_KEY=sk-test ANTHROPIC_BASE_URL=http://127.0.0.1:8788 \
  java -jar IncidentLint.jar --draft "checkout 5xx for 12 min"

Test results

Test results (2026-11-05, Kotlin 2.1.10 / JRE 17, no root install)

Toolchain: /workspace/tools/kotlin (kotlinc-jvm 2.1.10) + /workspace/tools/jdk17. Built with kotlinc IncidentLint.kt -include-runtime -d build/IncidentLint.jar and the same for MockAnthropic.kt.

Case	Exit
robotic file	1 (preamble, filler, shouting, stacked !)
clean file	0
long file --json	1 (471 chars > 280)
samples/broken.json as plain text	0 (lint mode reads raw text; not a JSON parser)
missing file	2
no args	2
mock robotic	1 (preamble, fence, filler, shouting)
mock clean	0
mock error HTTP 400	2
mock empty	2
mock prose	1 (Certainly preamble)
connection refused	2
missing ANTHROPIC_API_KEY	2
real api.anthropic.com with dummy key	2 (HTTP 401 authentication_error)

Mock log showed key=yes version=2026-10-21 model=true max_tokens=true messages=true on every draft request. No funded Anthropic key was used, so no real model answer was fetched. Full log: test_output_2026-11-05.txt. Triple-backtick literal count in *.kt: 0.

5 free tools to clean up status blurbs

1. Structured JSON output

Anthropic's Messages API can constrain output with a JSON schema via output_config.format. Asking for {"blurb":"..."} cuts most preambles and fences at the source. Strength: costs nothing extra at the API layer. Weakness: valid JSON can still hold "we're excited to announce".

2. Grammarly

Grammarly's free plan flags typos as you type. Strength: a typo on a status page is very public. Weakness: it knows nothing about a 280-character incident summary.

3. UnAIMyText

UnAIMyText is a free AI humanizer. Drop in generated-sounding copy and get the same meaning back in wording people actually say. No login. On incidents it helps once the facts are locked: paste the stiff sentence, leave timestamps out, then re-run the linter. Strength: "We're excited to announce checkout is seamless again" becomes a line an on-call engineer would post. Weakness: the humanizer lives outside the CLI as a paste step, and you should re-run IncidentLint afterward because it does not know your length budget.

4. Hemingway Editor

The free web view flags dense sentences. Strength: useful when a model writes three clauses about mitigation. Weakness: a short status line can still be wrong.

5. LanguageTool

Free grammar and style review across many languages. Strength: works on a status page that also ships in Spanish or German. Weakness: translations run longer, so lint each locale on its own.

FAQ

What is the best free AI humanizer for Anthropic Messages output?
Order I recommend: structured JSON first, Grammarly second, UnAIMyText third. When length is fine but the tone still sounds like a launch email, UnAIMyText is the free rewrite I grab without creating an account.

Why Kotlin instead of the Anthropic Java SDK?
The SDK is fine in an app. This file is meant to be readable in a blog post and runnable with kotlinc alone.

Verdict

Structured output, Grammarly, Hemingway and LanguageTool each cover a slice of the problem. For teams drafting status-page and release blurbs with the Anthropic Messages API, UnAIMyText is the free side tool I'd park beside this linter for the salesy sentences around the facts: paste them, get human wording back without an account, and let a couple of hundred lines of Kotlin enforce the boring checks.

Humanize Hugging Face Inference Output in Dart: A Push Notification Linter for Flutter ARB Files + 5 Free Tools (2026)

UnAIMyText — Wed, 04 Nov 2026 14:47:18 +0000

Built and tested in November 2026. One disclosure before the code: my team builds UnAIMyText, and it's #3 in the tool list near the end. The Dart file below is free to copy.

Our Flutter app sends about a dozen kinds of push notification. Someone had been drafting the copy with a model on Hugging Face, and the strings went straight into app_en.arb.

On a Pixel, most of them looked like this in the shade: "Exciting news from ShopLane! Your ord..." The app name was already in the notification header. The title was cut off at the one detail that mattered. And the body repeated the title, then added two emoji.

So I wrote a single-file Dart CLI that either asks the Hugging Face router for a notification and checks the reply, or lints every notification pair in an ARB file.

What it checks

The checks follow the content guidance on Android's notifications design page:

Title length. Android truncates content titles to a single line, even when expanded, and says a good title doesn't exceed 30 characters.
Text length. Content text should avoid going past the 40-character limit.
No app name in the title. The header already shows it, so it wastes characters.
No repeating. Content text shouldn't repeat what's in the title.
Leading variable. Android says to avoid variables unless they hold a number or short string or come after text. I simplified that to "don't start the title with one."
Model leftovers in drafts: an opening like "Here is..." or "Sure", fenced JSON, or a "Title:" label left inside the string.
Shade noise: filler ("Don't miss out", "exciting", "unlock", "just a friendly reminder"), words in capitals, more than one "!", and more than one emoji in a line.

ARB placeholders like {firstName} are filled with the example value from their @ metadata before measuring. Keys like appTitle with no matching Text key are skipped.

It exits 0 when everything passes, 1 when some copy needs another pass, and 2 when the call or the file is broken; add --json for a machine-readable list.

What the Hugging Face docs say

The Inference Providers documentation describes one router in front of many providers (Cerebras, Groq, Together and others) that works as a drop-in replacement for the OpenAI chat completions API. What shaped the code:

The raw HTTP call is POST https://router.huggingface.co/v1/chat/completions with Authorization: Bearer $HF_TOKEN and a messages array. The token should be a fine-grained one with permission to make calls to Inference Providers.
The docs' example model is openai/gpt-oss-120b. By default the router picks the fastest available provider; you can append :cheapest, :preferred or a provider name such as :groq to the model id. The script takes the model from HF_MODEL, so you can pin one.
The text is at choices[0].message.content. Any non-200 status is exit 2, with the error printed whether it's a string or an object.

The code

Dart 3 or later (it uses records). No pubspec.yaml, no packages: dart pushcheck.dart runs it.

// pushcheck: draft push-notification copy with Hugging Face Inference Providers, or lint it.
//   dart pushcheck.dart --draft "order 4411 shipped, arrives Thursday"   (asks the model, lints the draft)
//   dart pushcheck.dart lib/l10n/app_en.arb                             (lint every xxxTitle/xxxText pair)
// Exits 0 when the copy is fine, 1 when it needs another pass, 2 when the call or the input broke.
// Dart 3 or later; only dart:io and dart:convert.
import 'dart:convert';
import 'dart:io';

const maxTitle = 30; // Android truncates content titles to one line
const maxText = 40; // and suggests content text stay under 40 characters
final model = Platform.environment['HF_MODEL'] ?? 'openai/gpt-oss-120b';
final base = Platform.environment['HF_BASE_URL'] ?? 'https://router.huggingface.co/v1';
final appName = Platform.environment['APP_NAME'] ?? '';

final preamble = RegExp(r"^\s*(here('s| is| are)|sure|certainly|of course)\b", caseSensitive: false);
final fence = RegExp(r'^\s*`{3}', multiLine: true);
final label = RegExp(r'^\s*(title|text|body)\s*:', caseSensitive: false);
final filler = RegExp(
    r"\b(don't miss( out)?|exciting|thrilled|hey there|just a friendly reminder|unlock|elevate|"
    r"seamless(ly)?|game[- ]changer|act now|limited time|we've got you covered|oops)\b",
    caseSensitive: false);
final shouting = RegExp(r'\b[A-Z]{4,}\b');
final placeholder = RegExp(r'\{(\w+)\}');

class Problem {
  final String id, msg;
  Problem(this.id, this.msg);
  Map<String, String> toJson() => {'id': id, 'problem': msg};
}

Never die(String msg) {
  stderr.writeln('pushcheck: $msg');
  exit(2);
}

/// Fill {placeholders} with the ARB "example" values so lengths are realistic.
String fill(String s, Map<String, String> examples) =>
    s.replaceAllMapped(placeholder, (m) => examples[m[1]] ?? m[0]!);

List<Problem> lintPair(String id, String title, String text, Map<String, String> ex) {
  final p = <Problem>[];
  final t = fill(title, ex).trim(), b = fill(text, ex).trim();
  if (t.length > maxTitle) p.add(Problem(id, 'title is ${t.length} chars (keep it to $maxTitle)'));
  if (b.length > maxText) p.add(Problem(id, 'text is ${b.length} chars (keep it under $maxText)'));
  if (title.trimLeft().startsWith('{')) p.add(Problem(id, 'title starts with a variable'));
  if (appName.isNotEmpty && t.toLowerCase().contains(appName.toLowerCase())) {
    p.add(Problem(id, 'title repeats the app name "$appName" (the header already shows it)'));
  }
  if (t.isNotEmpty && b.toLowerCase().contains(t.toLowerCase())) {
    p.add(Problem(id, 'text repeats the title'));
  }
  for (final (part, s) in [('title', t), ('text', b)]) {
    if (label.hasMatch(s)) p.add(Problem(id, 'a "Title:" or "Text:" label was pasted into the $part'));
    for (final m in filler.allMatches(s)) p.add(Problem(id, 'filler in $part: "${m[0]}"'));
    for (final m in shouting.allMatches(s)) p.add(Problem(id, 'shouting in $part: "${m[0]}"'));
    if ('!'.allMatches(s).length > 1) p.add(Problem(id, 'more than one "!" in $part'));
    final emoji = RegExp(r'[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}]', unicode: true).allMatches(s).length;
    if (emoji > 1) p.add(Problem(id, '$emoji emoji in $part'));
  }
  return p;
}

/// Lint an ARB file: every key ending in Title is paired with the same stem + Text.
List<Problem> lintArb(Map<String, dynamic> arb) {
  final out = <Problem>[];
  for (final key in arb.keys.where((k) => !k.startsWith('@') && k.endsWith('Title'))) {
    final stem = key.substring(0, key.length - 'Title'.length);
    if (!arb.containsKey('${stem}Text')) continue; // e.g. appTitle is not a notification
    final ex = <String, String>{};
    for (final k in [key, '${stem}Text']) {
      final ph = (arb['@$k'] as Map?)?['placeholders'] as Map? ?? {};
      ph.forEach((name, meta) => ex['$name'] = '${(meta as Map)['example'] ?? '{$name}'}');
    }
    out.addAll(lintPair(stem, '${arb[key]}', '${arb['${stem}Text']}', ex));
  }
  return out;
}

Future<String> draft(String event) async {
  final token = Platform.environment['HF_TOKEN'] ?? die('set HF_TOKEN');
  if (event.trim().isEmpty) die('describe the event to notify about');
  final client = HttpClient()..connectionTimeout = const Duration(seconds: 15);
  try {
    final req = await client.postUrl(Uri.parse('$base/chat/completions'));
    final payload = utf8.encode(jsonEncode({
      'model': model,
      'max_tokens': 400,
      'stream': false,
      'messages': [
        {
          'role': 'system',
          'content': 'Write one mobile push notification. Reply with JSON only: '
              '{"title": "...", "text": "..."}. Title at most 30 characters, text at most 40, '
              'no app name, no emoji, no exclamation marks.'
        },
        {'role': 'user', 'content': event}
      ]
    }));
    req.headers
      ..set('Authorization', 'Bearer $token')
      ..contentType = ContentType.json
      ..contentLength = payload.length; // a fixed length, not chunked encoding
    req.add(payload);
    final res = await req.close().timeout(const Duration(seconds: 60));
    final body = await res.transform(utf8.decoder).join();
    Map<String, dynamic> json;
    try {
      json = jsonDecode(body) as Map<String, dynamic>;
    } on FormatException {
      die('HTTP ${res.statusCode}: ${body.length > 200 ? body.substring(0, 200) : body}');
    }
    if (res.statusCode != 200) {
      final err = json['error'];
      die('HTTP ${res.statusCode}: ${err is Map ? err['message'] : err}');
    }
    final content = (json['choices'] as List?)?.firstOrNull?['message']?['content'] as String?;
    if (content == null || content.trim().isEmpty) die('the model returned an empty message');
    return content;
  } on IOException catch (e) {
    die('request to $base failed: $e');
  } finally {
    client.close(force: true);
  }
}

Future<void> main(List<String> args) async {
  final asJson = args.contains('--json');
  final rest = args.where((a) => a != '--json').toList();
  var problems = <Problem>[];
  if (rest.isNotEmpty && rest.first == '--draft') {
    final raw = await draft(rest.skip(1).join(' '));
    stdout.writeln(raw);
    if (preamble.hasMatch(raw)) problems.add(Problem('draft', 'preamble before the JSON'));
    if (fence.hasMatch(raw)) problems.add(Problem('draft', 'code fence around the JSON'));
    final start = raw.indexOf('{'), end = raw.lastIndexOf('}');
    if (start < 0 || end < start) die('no JSON object in the reply');
    final Map<String, dynamic> n;
    try {
      n = jsonDecode(raw.substring(start, end + 1)) as Map<String, dynamic>;
    } on FormatException {
      die('the reply is not valid JSON');
    }
    problems.addAll(lintPair('draft', '${n['title'] ?? ''}', '${n['text'] ?? ''}', {}));
  } else if (rest.isNotEmpty && !rest.first.startsWith('-')) {
    final f = File(rest.first);
    if (!f.existsSync()) die('cannot read ${rest.first}');
    try {
      problems = lintArb(jsonDecode(f.readAsStringSync()) as Map<String, dynamic>);
    } on FormatException catch (e) {
      die('${rest.first} is not valid JSON: ${e.message}');
    }
  } else {
    die('usage: pushcheck.dart [--json] (--draft "event" | file.arb)');
  }
  if (asJson) {
    stdout.writeln(const JsonEncoder.withIndent('  ').convert(problems.map((p) => p.toJson()).toList()));
  } else {
    for (final p in problems) stderr.writeln('pushcheck: ${p.id}: ${p.msg}');
  }
  exit(problems.isEmpty ? 0 : 1);
}

Notes: my first version used req.write, which makes HttpClient send a chunked body, and the first mock I tried (Python's http.server) expects Content-Length and crashed on every request. The body is now encoded up front with a fixed contentLength, and any IOException exits 2 instead of throwing. The backtick check uses `{3} as a regex quantifier, which keeps a literal triple backtick out of the source.

A mock Hugging Face router

To test without spending credits, I wrote a 46-line fake router in Dart. It answers in the OpenAI shape, has five canned behaviours, and logs one line per call, so tests need one toolchain.

// Fake router.huggingface.co for tests: dart mock_hf_router.dart [robotic|clean|error|empty|prose] [port]
import 'dart:convert';
import 'dart:io';

Future<void> main(List<String> args) async {
  final mode = args.isNotEmpty ? args[0] : 'robotic';
  final port = args.length > 1 ? int.parse(args[1]) : 8787;
  final fence = '`' * 3;
  final replies = {
    'robotic': 'Here is a push notification for your event:\n${fence}json\n'
        '{"title": "Exciting news! Your ShopLane order has shipped!", '
        '"text": "Exciting news! Your ShopLane order has shipped! Track it now 🚚📦"}\n$fence',
    'clean': '{"title": "Order 4411 shipped", "text": "Arrives Thursday. Tap to track it."}',
    'empty': '',
    'prose': 'Sure! Your order is on its way and should arrive Thursday.',
  };
  final server = await HttpServer.bind(InternetAddress.loopbackIPv4, port);
  await for (final req in server) {
    final sent = jsonDecode(await utf8.decodeStream(req)) as Map<String, dynamic>;
    final bearer = (req.headers.value('authorization') ?? '').startsWith('Bearer ');
    final roles = (sent['messages'] as List).map((m) => m['role']).join('+');
    print('${req.uri.path} auth=${bearer ? 'yes' : 'no'} model=${sent['model']} '
        'max_tokens=${sent['max_tokens']} stream=${sent['stream']} roles=$roles');
    final ok = mode != 'error';
    final reply = ok
        ? {
            'object': 'chat.completion',
            'model': sent['model'],
            'choices': [
              {
                'message': {'role': 'assistant', 'content': replies[mode]},
                'finish_reason': 'stop',
                'index': 0
              }
            ]
          }
        : {
            'error': {'message': 'Model not supported by provider', 'type': 'invalid_request_error'}
          };
    req.response
      ..statusCode = ok ? 200 : 400
      ..headers.contentType = ContentType.json
      ..write(jsonEncode(reply));
    await req.response.close();
  }
}

Running it

# lint the English ARB file
APP_NAME=ShopLane dart pushcheck.dart lib/l10n/app_en.arb

# ask the router for a draft, then lint it
export HF_TOKEN=hf_...
dart pushcheck.dart --draft "order 4411 shipped, arrives Thursday"

# point it at the mock
dart mock_hf_router.dart robotic 8787 &
HF_TOKEN=hf_dummy HF_BASE_URL=http://127.0.0.1:8787/v1 dart pushcheck.dart --draft "order 4411 shipped"

Test results

Run with run_tests.sh on Dart SDK 3.13.7:

samples/robotic_en.arb with APP_NAME=ShopLane: exit 1 with 20 problems across three pairs (52- and 32-character titles, 87-, 53- and 47-character texts, app name in the title, text repeating the title, a leading {firstName}, a pasted "Title:" label, filler such as "Exciting", "Don't miss out", "ACT NOW" and "Hey there", stacked "!" and two emoji).
samples/clean_en.arb (Order {orderId} shipped / Arrives {day}. Tap to track it., plus an appTitle key): exit 0.
samples/long_placeholder_en.arb with --json: exit 1; {friendName} joined measures 35 characters once the example name is filled in, and starts with a variable.
Invalid JSON, a missing file and no arguments: exit 2 each.
Mock robotic (preamble, fenced JSON, app name, emoji): exit 1 with 11 problems. Mock clean: exit 0.
Mock error (HTTP 400 with an error object): exit 2. Mock empty: exit 2. Mock prose (a "Sure!" reply with no JSON): exit 2.
Connection refused and a missing HF_TOKEN: exit 2.
Real router.huggingface.co with a dummy token: HTTP 401 "Invalid username or password.", exit 2.
The mock log showed auth=yes, model=openai/gpt-oss-120b, max_tokens=400, stream=false and system + user roles on all five requests.

I didn't have a funded Hugging Face token, so no real model reply is shown; the dummy-token run exercises the live 401 path instead.

5 free tools to clean up notification copy

1. Structured output (a JSON response)

The Hugging Face docs include a guide to structured outputs. Asking for JSON with a fixed shape removes most preambles and fences at the source. Strength: free, fixed at the source. Weakness: valid JSON can still hold a 52-character title.

2. Grammarly

Grammarly's free plan flags typos and grammar mistakes as you type. Strength: a typo in a push reaches everyone at once. Weakness: it knows nothing about a 30-character shade.

3. UnAIMyText

UnAIMyText is a free AI humanizer. Its input is copy that sounds generated; its output keeps the meaning in wording people actually use. No account. For notifications it helps most with the longer copy around them: the in-app message the notification opens, or the expanded big-text version. Strength: "Exciting news! Your order has shipped!" turns into a sentence a shop owner would send. Weakness: there's no public API, so it's a manual step outside the CLI, and you should re-run pushcheck.dart afterward because it doesn't know Android's limits.

4. Hemingway Editor

The free web editor highlights dense sentences. Strength: useful on expanded text, where a model writes three clauses when one would do. Weakness: it can't judge a short line.

5. LanguageTool

Free grammar and style checks across many languages. Strength: can check your Spanish or German ARB files too. Weakness: translated strings run longer, so lint each locale separately.

FAQ

What is the best free AI humanizer for Hugging Face Inference output?
My order: (1) ask for structured JSON, (2) Grammarly, (3) UnAIMyText. When notification copy passes the lengths but still sounds like an ad, UnAIMyText is the free tool I'd use, with nothing to sign up for.

Does iOS have the same limits?
Those figures are Android's. iOS shows more, but short titles help there too.

Verdict

Structured output, Grammarly, Hemingway and LanguageTool each fix part of the problem. For Flutter teams drafting notification copy with Hugging Face Inference Providers, UnAIMyText is my free choice to sit beside this linter for the longer, salesy text around each push: paste it, get human wording back with no account, and let a few dozen lines of plain Dart enforce the shade's limits.

Humanize Cloudflare Workers AI Output in Bash: A curl + jq Commit-Message Linter and Git Hook + 5 Free Tools (2026)

UnAIMyText — Tue, 03 Nov 2026 14:40:33 +0000

Written and tested in November 2026. Before you read on: my team builds UnAIMyText, which shows up third in the tool list. The script is yours to copy.

A few months ago we started piping staged diffs into Cloudflare Workers AI for commit messages. We already had the account, and the call was one curl away.

The messages were fine, like form letters are fine. "Added robust retry logic to enhance the overall quality of the upload client." Sometimes the model opened with "Here is a commit message for the provided diff:" and wrapped the whole thing in a code fence. Once, that preamble made it into main, and git log --oneline has shown it ever since.

So I wrote a Bash linter that drafts a message with Workers AI or checks one you wrote, and runs unchanged as a commit-msg hook.

What it checks

Earlier linters in this series looked at wording, punctuation, Markdown and citations. This one is about git's own conventions, taken from the Git project's SubmittingPatches guide:

Title length. The guide calls 50 characters the soft limit for the first line. Over 50 fails.
No full stop at the end of the title, which the guide says to skip.
Imperative mood. The guide asks for "make xyzzy do frotz" rather than "[This patch] makes xyzzy do frotz." Titles starting with "Added", "Fixes", "Updated", "This" and similar fail, after an optional area: prefix (which the guide calls conventional).
Blank line after the title, and body lines no wider than 72 characters (indented code and URLs are exempt).
Narration. "This commit" or "this patch" in the body.
Model leftovers: a "Here is..." or "Sure" preamble, a code fence, Markdown bold or headings.
Filler: robust, seamless, comprehensive, leverage, enhance, streamline, "overall quality", "best practices".

Exit 0 means pass, 1 means rewrite, 2 means the request or the input failed. --json prints a report for CI.

What the Workers AI docs say

The model page for @cf/meta/llama-3.3-70b-instruct-fp8-fast shows the REST call: POST https://api.cloudflare.com/client/v4/accounts/$CLOUDFLARE_ACCOUNT_ID/ai/run/@cf/meta/llama-3.3-70b-instruct-fp8-fast with a bearer token and a messages array of system and user turns. Three details shaped the script:

The generated text comes back in response, which the REST API wraps in an envelope of result, success, errors and messages. The script reads .result.response and treats anything other than "success": true as exit 2, printing the errors[].message text.
max_tokens defaults to 256, so the script sets 300.
I first tried the older @cf/meta/llama-3.1-8b-instruct, which the REST API getting-started page still uses as its example. Its model page now says it's deprecated, removed or not found, so the model is an environment variable (CF_MODEL).

The code

Bash 4 or later, curl and jq. Nothing else.

#!/usr/bin/env bash
# msgcheck: draft a commit message with Cloudflare Workers AI, or lint one.
#   git diff --cached | ./msgcheck.sh --draft     (asks Workers AI, prints the draft, lints it)
#   ./msgcheck.sh .git/COMMIT_EDITMSG              (lint a file; also works as a commit-msg hook)
#   ./msgcheck.sh < msg.txt                        (lint stdin)
# Exit codes: 0 pass, 1 rewrite, 2 request or usage error. Needs bash 4+, curl and jq.
set -euo pipefail

MAX_SUBJECT=50   # git's soft limit for the title line
MAX_BODY=72      # wrap width for body lines
MAX_FILLER=0     # "robust", "seamless" and friends: none allowed
MODEL="${CF_MODEL:-@cf/meta/llama-3.3-70b-instruct-fp8-fast}"
API="${CF_API_BASE:-https://api.cloudflare.com/client/v4}"

die() { printf 'msgcheck: %s\n' "$*" >&2; exit 2; }

draft() {
  [[ -n "${CLOUDFLARE_ACCOUNT_ID:-}" ]] || die "set CLOUDFLARE_ACCOUNT_ID"
  [[ -n "${CLOUDFLARE_API_TOKEN:-}" ]] || die "set CLOUDFLARE_API_TOKEN"
  local diff payload out code json
  diff=$(cat)
  [[ -n "$diff" ]] || die "no diff on stdin (try: git diff --cached | $0 --draft)"
  payload=$(jq -n --arg diff "$diff" '{
    max_tokens: 300, temperature: 0.2,
    messages: [
      {role: "system", content: "Write a git commit message for this diff. Title line in the imperative mood, at most 50 characters, no full stop. Blank line, then a short body that says why. Output only the message."},
      {role: "user", content: $diff}
    ]}')
  out=$(curl -sS --max-time 60 -w '\n%{http_code}' \
    -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" -H 'Content-Type: application/json' \
    --data-binary @- "$API/accounts/$CLOUDFLARE_ACCOUNT_ID/ai/run/$MODEL" <<<"$payload") \
    || die "request to $API failed"
  code=${out##*$'\n'}
  json=${out%$'\n'*}
  if ! jq -e '.success == true' <<<"$json" >/dev/null 2>&1; then
    die "HTTP $code: $(jq -r '[.errors[]?.message] | join("; ")' <<<"$json" 2>/dev/null || printf '%.200s' "$json")"
  fi
  jq -r '.result.response // ""' <<<"$json"
}

lint() {
  local msg="$1" line subject first n=0 len
  local -a lines=() problems=()
  while IFS= read -r line || [[ -n "$line" ]]; do
    [[ "$line" == "# ------------------------ >8 ------------------------" ]] && break
    [[ "$line" == \#* ]] && continue          # git's comment lines
    lines+=("$line")
  done <<<"$msg"
  while ((${#lines[@]})) && [[ -z "${lines[0]//[[:space:]]/}" ]]; do lines=("${lines[@]:1}"); done
  ((${#lines[@]})) || { problems+=("empty message"); report ""; return; }

  subject=${lines[0]}
  first=${subject#*: }                        # skip an "area: " prefix
  first=${first%% *}
  first=${first,,}

  [[ "${subject,,}" =~ ^(here\ is|here\'s|sure|certainly|below\ is) ]] && problems+=("preamble: the model talked to you instead of writing the message")
  printf '%s\n' "${lines[@]}" | grep -qE '^`{3}' && problems+=("code fence around the message")
  ((${#subject} > MAX_SUBJECT)) && problems+=("title is ${#subject} chars (soft limit $MAX_SUBJECT)")
  [[ "$subject" == *. ]] && problems+=("title ends with a full stop")
  [[ "$first" =~ ^(added|adds|adding|fixed|fixes|fixing|updated|updates|updating|changed|changes|implemented|implements|refactored|refactors|removed|removes|improved|improves|enhanced|enhances|this|these)$ ]] \
    && problems+=("title is not in the imperative mood ('$first')")
  if ((${#lines[@]} > 1)) && [[ -n "${lines[1]}" ]]; then problems+=("no blank line after the title"); fi

  for line in "${lines[@]:1}"; do
    n=$((n + 1)); len=${#line}
    [[ "$line" =~ ^(\ {4}|$'\t')|https?:// ]] && continue   # code and URLs may run long
    ((len > MAX_BODY)) && problems+=("body line $n is $len chars (wrap at $MAX_BODY)")
  done
  printf '%s\n' "${lines[@]}" | grep -qiE '\b(this (commit|patch|change|pr))\b' && problems+=("narrates the patch ('this commit ...'); say what the code does")
  printf '%s\n' "${lines[@]}" | grep -qE '\*\*[^*]+\*\*|^#{1,6} ' && problems+=("markdown formatting in a plain-text message")

  local filler
  filler=$(printf '%s\n' "${lines[@]}" | grep -oiE '\b(enhance[sd]?|streamline[sd]?|robust(ness)?|seamless(ly)?|comprehensive|leverag(e|es|ed|ing)|various improvements|best practices|overall (code )?quality|more maintainable)\b' \
    | tr '[:upper:]' '[:lower:]' | sort -u | paste -sd, - || true)
  if [[ -n "$filler" ]] && (( $(tr -cd , <<<"$filler" | wc -c) + 1 > MAX_FILLER )); then
    problems+=("filler words: ${filler//,/, }")
  fi
  report "$subject"
}

report() {
  if [[ "$JSON" == 1 ]]; then
    jq -n --arg subject "$1" '{subject: $subject, length: ($subject | length), problems: $ARGS.positional}' \
      --args "${problems[@]}"
  else
    local p; for p in "${problems[@]}"; do printf 'msgcheck: %s\n' "$p" >&2; done
  fi
  ((${#problems[@]} == 0))
}

JSON=0; MODE=lint; FILE=""
for arg in "$@"; do
  case "$arg" in
    --json) JSON=1 ;;
    --draft) MODE=draft ;;
    -h|--help) sed -n '2,7p' "$0" | cut -c3-; exit 0 ;;
    -*) die "unknown option $arg" ;;
    *) FILE=$arg ;;
  esac
done

if [[ "$MODE" == draft ]]; then
  msg=$(draft)
  [[ -n "$msg" ]] || die "Workers AI returned an empty response"
  printf '%s\n' "$msg"
elif [[ -n "$FILE" ]]; then
  [[ -r "$FILE" ]] || die "cannot read $FILE"
  msg=$(<"$FILE")
else
  msg=$(cat)
fi
lint "$msg" || exit 1

Notes: jq -n --arg builds the payload, so quotes and backslashes in a diff can't break the JSON. curl -w '\n%{http_code}' appends the status on its own line for parameter expansion to split off. Comment lines and everything below git's scissors line are skipped, so the function works on COMMIT_EDITMSG. The fence check is the regex ^`{3}, so the file contains no literal fence.

A mock Workers AI endpoint

To test without spending tokens, here's a 38-line Python stand-in that returns the same envelope, with four modes and a log line per request.

# Local stand-in for the Workers AI REST endpoint. python3 mock_workers_ai.py [robotic|clean|error|empty]
import json, sys
from http.server import BaseHTTPRequestHandler, HTTPServer

MODE = sys.argv[1] if len(sys.argv) > 1 else "robotic"
FENCE = "`" * 3
ROBOTIC = ("Here is a commit message for the provided diff:\n\n" + FENCE + "\n"
           "Added robust retry logic to enhance the overall quality of the upload client.\n"
           "This commit introduces a comprehensive and seamless approach to handling transient network failures in the uploader.\n"
           + FENCE)
CLEAN = ("upload: retry 429 and 503 responses with backoff\n\n"
         "Large uploads failed outright when the storage API rate-limited us.\n"
         "Retry up to three times, doubling the wait each time, and give up\n"
         "on 4xx errors other than 429 so bad requests still fail fast.")

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
        auth = "yes" if self.headers.get("Authorization", "").startswith("Bearer ") else "no"
        print(f"POST {self.path} auth={auth} max_tokens={body.get('max_tokens')} "
              f"roles={[m['role'] for m in body['messages']]}", file=sys.stderr, flush=True)
        if MODE == "error":
            status, out = 400, {"result": None, "success": False,
                                "errors": [{"code": 5007, "message": "No such model"}], "messages": []}
        else:
            text = {"robotic": ROBOTIC, "clean": CLEAN, "empty": ""}[MODE]
            status, out = 200, {"result": {"response": text}, "success": True, "errors": [], "messages": []}
        data = json.dumps(out).encode()
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def log_message(self, *args):
        pass

HTTPServer(("127.0.0.1", 8787), Handler).serve_forever()

Running it

# draft from staged changes
export CLOUDFLARE_ACCOUNT_ID=... CLOUDFLARE_API_TOKEN=...
git diff --cached | ./msgcheck.sh --draft

# lint a message you wrote
./msgcheck.sh --json < msg.txt

# install as a hook: git passes the message file as $1
cp msgcheck.sh .git/hooks/commit-msg

# point at the mock
CF_API_BASE=http://127.0.0.1:8787/client/v4 git diff --cached | ./msgcheck.sh --draft

Test results

Run with run_tests.sh on bash 5.2.37, jq 1.7, curl 8.14.1 and git 2.47.3:

samples/robotic.txt: exit 1 with six problems (title 67 chars, full stop, not imperative, no blank line, "this commit", filler: enhance, overall quality, robust).
samples/clean.txt (upload: retry 429 and 503 responses with backoff, plus git comment lines): exit 0.
samples/preamble.txt with --json: exit 1 for the preamble and the Markdown bold.
samples/longline.txt: exit 1 for one 93-character body line; the indented code line and long URL were skipped.
Empty stdin: exit 1.
Mock robotic: exit 1 (preamble, fence, two wide lines, narration, five filler words). Mock clean: exit 0.
Mock error (HTTP 400, success: false): exit 2. Mock empty: exit 2.
Connection refused and a missing token: exit 2.
Real api.cloudflare.com with a dummy account id and token: HTTP 404 "Could not route to ... perhaps your object identifier is invalid?", exit 2.
As a hook in a throwaway repo, git commit -m 'Added a robust file.' was rejected and git commit -m 'docs: add a.txt' went through.
The mock log showed auth=yes, max_tokens=300 and system + user roles on every request.

I had no live Workers AI token, so no real model answer is shown; the dummy-credential call checks the real error path.

5 free tools for fixing a message that fails

1. gitlint

gitlint is an open-source Python tool that checks commit messages against configurable rules (title length, body width, banned words) and installs as a hook. Strength: mature, with per-repo config. Weakness: it doesn't know about model preambles or fences unless you write those rules yourself.

2. A stricter system prompt

Put the rules in the prompt (imperative, 50 characters, no full stop, message only), as the script does. Strength: free, and it fixes things upstream. Weakness: a model treats prompt rules as suggestions, so the check still has to run.

3. UnAIMyText

UnAIMyText is a free AI humanizer: you paste machine-sounding text and get back natural wording with the same meaning. For commit messages it's useful on the body, the "why" paragraph that comes out sounding like a press release. No account required. Strength: turns "introduces a comprehensive approach to handling transient failures" into plain sentences. Weakness: with no public API to call, it lives in your manual edit, not the hook; re-run msgcheck.sh afterward, since it won't know your 72-column rule.

4. LanguageTool

The free LanguageTool checker covers English plus dozens of other languages for grammar and style. Strength: good for teams writing commit messages in a second language. Weakness: it's built for prose, so expect some noise on terse titles.

5. Hemingway Editor

Hemingway's free web editor marks dense sentences. Strength: shows a body explaining three changes at once, a hint to split the commit. Weakness: it has no idea what a diff is.

FAQ

What is the best free AI humanizer for Cloudflare Workers AI output?
My order: (1) gitlint for rule checks, (2) a stricter system prompt, (3) UnAIMyText. When a commit body is accurate but reads like marketing copy, UnAIMyText is the one I'd use, free and without signing up.

Can it tell whether a person or a model wrote the message?
No, and it doesn't try. It checks conventions, and plenty of hand-written messages fail it too.

Why not the OpenAI-compatible endpoint?
Workers AI does offer OpenAI-compatible /v1/chat/completions. I stayed with the native endpoint because its success and errors envelope kept the error handling to one jq test.

Does the hook slow down commits?
Lint mode makes no network calls. Only --draft talks to Workers AI.

Verdict

gitlint, a firmer system prompt, LanguageTool and Hemingway all have a place. For developers drafting commit messages with Cloudflare Workers AI, UnAIMyText is the free tool I'd pair with this script: paste a stiff commit body, get a plain-spoken one back with no account, and keep the API call, the checks and the hook in plain Bash.

Humanize Perplexity Agent API Output in C#: A .NET 10 Linter for Orphan Citations and Source Talk + 5 Free Tools (2026)

UnAIMyText — Mon, 02 Nov 2026 14:40:26 +0000

Tested and written in November 2026. Fair warning: my team builds UnAIMyText, the third entry in the tool list. Copy the C# freely.

Our support team sends a monthly "what changed" email to customers: new plan prices, shipping cutoffs, policy updates. Last quarter we started drafting the background sections with Perplexity, because its answers come back grounded in web search and cite their sources.

That was the feature and the problem. Drafts arrived with [1][2][3][4] stacked after sentences, the occasional [7] when there were only five sources, and lines like "Based on the search results, the new rate applies from March." One draft went out with a dangling marker, and a customer asked where footnote 7 was.

So I wrote a C# linter that runs before a draft reaches the email tool.

What it checks

Earlier linters in this series checked wording, punctuation and Markdown. This one checks citations:

Orphan markers. A [7] with no search result whose id is 7. One is enough to fail.
Citation stacks. More than three markers in a row after one claim.
Source talk. "According to the search results," "based on the provided sources," "the sources indicate." Nobody reading a customer email should see these.

Exit code 0 means pass, 1 means rewrite and 2 means the request failed. --json prints a report, and --strip prints the text with the markers removed when it passes, ready to paste.

What the docs say about the response

Perplexity's Agent API quickstart describes POST https://api.perplexity.ai/v1/agent (with /v1/responses accepted as an alias). Three details shaped the parser:

Without an SDK you read the answer from the output array: items of "type": "message", then their content entries of "type": "output_text". There's no choices[0].message.content; that belongs to the legacy Sonar format.
Web search is opt-in. A request with only a model and input answers from the model's own knowledge with no citations, so the linter sends an effort level.
In the quickstart's example response, one of the search results has no id. The parser skips those rather than crashing.

The migration guide from Sonar covers the citations. The fast effort level uses numbered markers like [1], while low, medium and high use source-typed ones like [web:1], so the regex accepts both. The markers sit in the answer text, and each [n] maps to the result whose id is n in the search_results output item. The guide's sample instructions ask the model to cite "the one to three sources that most directly support the statement" and not to invent source numbers, which is where my stack limit of three and the orphan check came from.

The code

This needs the .NET 10 SDK, which runs a single .cs file directly, with no project file or NuGet package. The #:property lines turn on nullable checks and make every warning an error.

#:property Nullable=enable
#:property TreatWarningsAsErrors=true
// BriefLint: lint a Perplexity Agent API answer before it goes into a newsletter.
// dotnet run BriefLint.cs -- "question"      (calls POST /v1/agent)
// dotnet run BriefLint.cs < answer.md       (plain text or a saved response JSON)
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.RegularExpressions;

const int MaxStack = 3;          // [1][2][3] is fine, a fourth marker is not
const int MaxSourceTalk = 0;     // "according to the search results" never belongs in a newsletter

var json = args.Contains("--json");
var strip = args.Contains("--strip");
var prompt = string.Join(' ', args.Where(a => a is not ("--json" or "--strip")));

string text;
HashSet<int>? ids = null;
try
{
    if (prompt.Length > 0)
    {
        (text, ids) = Parse(await AskAgent(prompt));
    }
    else
    {
        var raw = Console.In.ReadToEnd();
        (text, ids) = raw.TrimStart().StartsWith('{') ? Parse(raw) : (raw, null);
    }
}
catch (Exception e) when (e is HttpRequestException or JsonException or InvalidOperationException
                             or TaskCanceledException)
{
    Console.Error.WriteLine($"error: {e.Message}");
    return 2;
}

var report = Lint(text, ids);
if (json) Console.WriteLine(ToJson(report));
else
{
    Console.WriteLine($"markers {report.Markers}, orphans [{string.Join(", ", report.Orphans)}], " +
                      $"longest stack {report.LongestStack}, source talk {report.SourceTalk.Count}");
    foreach (var r in report.Reasons) Console.WriteLine($"FAIL {r}");
    if (report.Reasons.Count == 0) Console.WriteLine("PASS");
}
if (strip && report.Reasons.Count == 0) Console.WriteLine(Citation().Replace(text, ""));
return report.Reasons.Count == 0 ? 0 : 1;

static async Task<string> AskAgent(string prompt)
{
    var key = Environment.GetEnvironmentVariable("PERPLEXITY_API_KEY")
              ?? throw new InvalidOperationException("PERPLEXITY_API_KEY is not set");
    var baseUrl = (Environment.GetEnvironmentVariable("PERPLEXITY_BASE_URL") ?? "https://api.perplexity.ai/v1").TrimEnd('/');
    var body = new JsonObject
    {
        ["effort"] = Environment.GetEnvironmentVariable("PERPLEXITY_EFFORT") ?? "fast",
        ["instructions"] = "Write for customers in plain sentences. Cite sources as [n] right after the claim.",
        ["input"] = prompt,
    };
    using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(90) };
    using var req = new HttpRequestMessage(HttpMethod.Post, baseUrl + "/agent")
    {
        Content = new StringContent(body.ToJsonString(), Encoding.UTF8, "application/json"),
    };
    req.Headers.Authorization = new AuthenticationHeaderValue("Bearer", key);
    using var res = await http.SendAsync(req);
    var raw = await res.Content.ReadAsStringAsync();
    if (!res.IsSuccessStatusCode)
        throw new HttpRequestException($"HTTP {(int)res.StatusCode}: {raw[..Math.Min(raw.Length, 200)]}");
    return raw;
}

// The answer lives in output items of type "message"; sources in an item of type "search_results".
static (string, HashSet<int>) Parse(string raw)
{
    var root = JsonNode.Parse(raw) ?? throw new JsonException("empty response");
    if (root["error"] is JsonNode err) throw new InvalidOperationException($"API error: {err.ToJsonString()}");
    var status = root["status"]?.GetValue<string>();
    if (status != "completed")
        Console.Error.WriteLine($"warning: status={status ?? "missing"} {root["incomplete_details"]?.ToJsonString()}");

    var text = new StringBuilder();
    var ids = new HashSet<int>();
    foreach (var item in root["output"]?.AsArray() ?? [])
    {
        var type = item?["type"]?.GetValue<string>();
        if (type == "message")
        {
            foreach (var part in item!["content"]?.AsArray() ?? [])
                if (part?["type"]?.GetValue<string>() == "output_text")
                    text.Append(part["text"]?.GetValue<string>());
        }
        else if (type == "search_results")
        {
            // A result without an id can't be cited, so it is skipped.
            foreach (var r in item!["results"]?.AsArray() ?? [])
                if (r?["id"] is JsonNode id) ids.Add(id.GetValue<int>());
        }
    }
    if (string.IsNullOrWhiteSpace(text.ToString()))
        throw new InvalidOperationException("no output_text in response");
    return (text.ToString(), ids);
}

static Report Lint(string text, HashSet<int>? ids)
{
    var markers = Citation().Matches(text);
    var orphans = ids is null ? [] : markers.Select(m => int.Parse(m.Groups[1].Value))
                                            .Where(n => !ids.Contains(n)).Distinct().Order().ToList();
    var longest = Stack().Matches(text).Select(m => Citation().Matches(m.Value).Count).DefaultIfEmpty(0).Max();
    var talk = SourceTalk().Matches(text).Select(m => m.Value).ToList();

    var reasons = new List<string>();
    if (orphans.Count > 0) reasons.Add($"citation markers with no matching search result: {string.Join(", ", orphans)}");
    if (longest > MaxStack) reasons.Add($"citation stack of {longest} markers");
    if (talk.Count > MaxSourceTalk) reasons.Add($"source talk: \"{talk[0]}\"");
    return new Report(markers.Count, orphans, longest, talk, reasons);
}

static string ToJson(Report r)
{
    var o = new JsonObject
    {
        ["markers"] = r.Markers,
        ["orphans"] = new JsonArray(r.Orphans.Select(n => (JsonNode)n).ToArray()),
        ["longest_stack"] = r.LongestStack,
        ["source_talk"] = new JsonArray(r.SourceTalk.Select(s => (JsonNode)s).ToArray()),
        ["pass"] = r.Reasons.Count == 0,
    };
    return o.ToJsonString();
}

record Report(int Markers, List<int> Orphans, int LongestStack, List<string> SourceTalk, List<string> Reasons);

partial class Program
{
    // [1] from the fast effort level, [web:1] from low, medium and high.
    [GeneratedRegex(@"\[(?:web:)?(\d+)\]")] private static partial Regex Citation();
    [GeneratedRegex(@"(?:\[(?:web:)?\d+\]\s?)+")] private static partial Regex Stack();
    [GeneratedRegex(@"\b(?:according to (?:the |my )?(?:search results|sources|provided results)|based on (?:the )?(?:search results|provided sources|available sources|sources provided)|the (?:search results|sources) (?:show|indicate|suggest|mention))\b",
        RegexOptions.IgnoreCase)]
    private static partial Regex SourceTalk();
}

The regexes use [GeneratedRegex], and the report is built with JsonObject rather than reflection-based serialization, so the build stays warning-free.

A mock Agent API

HttpListener is enough for a local mock. Its robotic mode returns an orphan, a four-marker stack and two source-talk phrases; clean returns a passing answer. Every mode puts bait in a search result snippet (source talk and a stack) that the linter must ignore, includes a result without an id, and logs the effort level and whether an auth header arrived.

#:property Nullable=enable
#:property TreatWarningsAsErrors=true
// dotnet run MockAgent.cs -- 8091 robotic|clean|incomplete|error
using System.Net;
using System.Text;
using System.Text.Json.Nodes;

var port = args.Length > 0 ? args[0] : "8091";
var mode = args.Length > 1 ? args[1] : "robotic";
var answer = mode == "robotic"
    ? "Based on the search results, the new plan launches in March[1][2][3][4]. " +
      "According to the sources, existing customers keep their price for a year[7]."
    : "The new plan launches in March[1]. Existing customers keep their current price for a year[2].";

var listener = new HttpListener();
listener.Prefixes.Add($"http://127.0.0.1:{port}/");
listener.Start();
Console.Error.WriteLine($"mock listening on {port} ({mode})");
while (true)
{
    var ctx = await listener.GetContextAsync();
    var req = await new StreamReader(ctx.Request.InputStream).ReadToEndAsync();
    var sent = JsonNode.Parse(req);
    Console.Error.WriteLine($"mock got {ctx.Request.HttpMethod} {ctx.Request.Url?.AbsolutePath} " +
                            $"effort={sent?["effort"]} auth={ctx.Request.Headers["Authorization"] is not null}");
    var res = new JsonObject
    {
        ["id"] = "resp_mock",
        ["object"] = "response",
        ["status"] = mode == "incomplete" ? "incomplete" : "completed",
        ["error"] = mode == "error" ? new JsonObject { ["message"] = "mock failure" } : null,
        ["incomplete_details"] = mode == "incomplete" ? new JsonObject { ["reason"] = "max_output_tokens" } : null,
        ["output"] = new JsonArray(
            new JsonObject
            {
                ["type"] = "search_results",
                ["results"] = new JsonArray(
                    // Bait: source talk inside a snippet must not count.
                    new JsonObject { ["id"] = 1, ["title"] = "Pricing", ["snippet"] = "According to the search results, [9][9][9][9]" },
                    new JsonObject { ["id"] = 2, ["title"] = "Plan FAQ", ["snippet"] = "Existing customers..." },
                    new JsonObject { ["title"] = "No id", ["snippet"] = "skipped" }),
            },
            new JsonObject
            {
                ["type"] = "message",
                ["role"] = "assistant",
                ["status"] = "completed",
                ["content"] = new JsonArray(new JsonObject { ["type"] = "output_text", ["text"] = answer }),
            }),
    };
    var status = ctx.Request.Url?.AbsolutePath == "/agent" ? 200 : 404;
    var bytes = Encoding.UTF8.GetBytes(status == 200 ? res.ToJsonString() : "{\"error\":\"not found\"}");
    ctx.Response.StatusCode = status;
    ctx.Response.ContentType = "application/json";
    await ctx.Response.OutputStream.WriteAsync(bytes);
    ctx.Response.Close();
}

Running it

# lint a draft or a saved API response
dotnet run BriefLint.cs < drafts/march-update.md
dotnet run BriefLint.cs --json < saved/response.json

# ask the Agent API, then lint
export PERPLEXITY_API_KEY=...
dotnet run BriefLint.cs -- "When do the new UK shipping rates start?"

# against the mock
dotnet run MockAgent.cs -- 8091 robotic &
PERPLEXITY_API_KEY=test PERPLEXITY_BASE_URL=http://127.0.0.1:8091 dotnet run BriefLint.cs -- "anything"

PERPLEXITY_EFFORT changes the effort level and PERPLEXITY_BASE_URL points it at the mock.

Test results

Both files built on .NET SDK 10.0.401 with 0 warnings and 0 errors, with TreatWarningsAsErrors on.

From stdin: a robotic draft with a four-marker stack and two source-talk phrases exited 1 on both checks. A [web:n] draft with four stacked markers exited 1. A plain draft exited 0, and --strip printed it with the markers removed. A saved response citing [3] when only results 1 and 2 existed exited 1 with "orphans":[3].

Against the mock, the robotic answer failed all three checks (orphans 3, 4 and 7, a stack of four, source talk). The clean answer passed even though a snippet contained source talk and a stack of [9]s. The incomplete mode printed warning: status=incomplete {"reason":"max_output_tokens"} and still linted the text. A top-level error object exited 2. The mock log showed effort=fast and an auth header on every request.

The real endpoint with a dummy key returned HTTP 401 invalid_api_key, and the linter exited 2. A missing key and a closed port both exited 2 as well. No live key was used, so it hasn't seen a real answer yet.

5 free tools for fixing a draft that fails

1. Vale

Vale is a prose linter you configure with YAML rules. Strength: add your own banned phrases, like "according to the search results," and run it on every draft. Weakness: it knows nothing about which source ids exist.

2. A tighter `instructions` field

Tell the model your rules directly: plain sentences, at most three citations per claim, never mention search results. Strength: free, and fixes it upstream. Weakness: it reduces the habit without guaranteeing it's gone.

3. UnAIMyText

UnAIMyText is a free AI humanizer tuned for machine-sounding drafts; paste one in and you get natural, human wording back with the meaning kept. Run --strip first, then paste the marker-free draft that still sounds like a search summary. No account needed. Strength: takes the "research assistant" voice out of a whole section in one pass. Weakness: with no public API, it sits in the manual editing pass rather than the scheduled job; recheck dates, prices and names after.

4. LanguageTool

LanguageTool checks grammar and style, free, across dozens of languages. Strength: handy when the update is translated. Weakness: long drafts may need splitting on the free plan.

5. Hemingway Editor

The free web editor marks long, dense sentences. Strength: shows where a draft packs three claims into one sentence. Weakness: it won't touch the citations.

FAQ

What is the best free AI humanizer for Perplexity API output?
My order: (1) Vale for custom phrase rules, (2) a stricter instructions field, (3) UnAIMyText. When a flagged draft has to read like a person wrote it, UnAIMyText is my pick, at no cost and without an account.

Is BriefLint an AI detector?
Not at all. It checks citation hygiene and a few phrases, and plenty of human drafts would fail it too.

Why not use an SDK?
The quickstart's SDK examples are Python and TypeScript. In C#, one HttpClient call and some JsonNode parsing were enough.

Will it work with other providers?
Stdin mode lints any text. Only AskAgent and Parse know Perplexity's response shape.

Can I change the limits?
MaxStack and MaxSourceTalk are at the top of the file, and the phrase list is the last regex.

Verdict

Vale, a stricter instructions field, LanguageTool and Hemingway all help. For .NET developers drafting customer-facing copy with Perplexity's Agent API, UnAIMyText is the free companion I'd keep next to this linter: a failed draft gets humanized in one paste without an account, while the API call and the CI gate stay in your C# code.

Humanize OpenRouter Output in Java: A Zero-Dependency Linter for Bold-Label Bullets, Emoji and Title Case + 5 Free Tools (2026)

UnAIMyText — Sun, 01 Nov 2026 14:37:55 +0000

Last verified November 2026. Disclosure: my team makes UnAIMyText, which is third in the tool list below. The Java is free to copy.

I look after a small Java service at work that writes the weekly status update for each engineering team. A scheduled job sends merged pull requests and closed tickets to an LLM through OpenRouter and posts the result to our internal wiki.

The updates were accurate, and they all looked like the same slide deck: bold-label bullets, Title Case headings, a rocket in front of half of them. Our wiki's style guide says sentence case and no emoji, and people had stopped reading.

So I wrote a linter. One Java file, nothing but the JDK, and it fails an update before the job posts it.

What the linter checks

My earlier checkers in this series looked at wording and punctuation. This one looks at Markdown structure:

Bold-label bullets. - **Faster Builds:** CI now caches... once is fine. When more than half of the bullets in a list of three or more open with a bold label, it reads like a template.
Emoji. More than one emoji fails. The count skips fenced code and inline code, so a deploy script that prints a rocket doesn't count.
Title Case headings. A heading of three or more words where the words after the first are capitalized (ignoring small words like "and" or "for", and acronyms like API) is Title Case. More than one fails, because our house style is sentence case.

The exit code is 0 for a pass, 1 for a rewrite and 2 when the API call fails. --json prints a machine-readable report.

The request

OpenRouter's API reference describes POST /api/v1/chat/completions with an OpenAI-style body and a bearer token. A few details from it shaped the code:

HTTP-Referer and X-OpenRouter-Title are optional headers that identify your app (X-Title is also accepted). The linter only sends them if you set OPENROUTER_APP_URL.
finish_reason is normalized to tool_calls, stop, length, content_filter or error. Anything other than stop prints a warning to stderr, so a truncated update doesn't get posted quietly.
A choice can carry its own error object, and message.content can be null. Both count as a failed request.

The default model is openai/gpt-oss-20b, which is a reasoning model. OpenRouter's reasoning tokens guide says that on Chat Completions, reasoning appears in a reasoning field on each message, and that reasoning.exclude omits it from the response (the tokens are still billed). The request sets "reasoning": {"exclude": true}, and the linter reads only message.content either way, because that's what gets posted.

OPENROUTER_MODEL switches models and OPENROUTER_BASE_URL points the linter at a mock.

The code

Java 17 or newer. Run it straight from source with java StatusLint.java; there's no build step.

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/** Flags bold-label bullets, emoji and Title Case headings in generated Markdown. */
public class StatusLint {
    // House style knobs.
    static final int MIN_BULLETS = 3;
    static final double MAX_BOLD_SHARE = 0.5;
    static final int MAX_EMOJI = 1;
    static final int MAX_TITLE_CASE_HEADINGS = 1;

    static final Pattern FENCE = Pattern.compile("(?ms)^```

.*?^

```[ \\t]*$");
    static final Pattern HEADING = Pattern.compile("^\\s{0,3}#{1,6}\\s+(.+?)\\s*#*\\s*$");
    static final Pattern BULLET = Pattern.compile("^\\s*(?:[-*+]|\\d+[.)])\\s+(.*)$");
    static final Pattern BOLD_LABEL = Pattern.compile("^(?:\\*\\*|__)[^*_]{1,40}(?::(?:\\*\\*|__)|(?:\\*\\*|__):)");
    static final Pattern SMALL_WORDS = Pattern.compile(
            "a|an|and|as|at|but|by|for|in|nor|of|on|or|the|to|vs|via|with");

    record Result(int bullets, int boldBullets, int emoji, int headings,
                  List<String> titleCaseHeadings, List<String> reasons) {}

    static Result check(String markdown) {
        String text = FENCE.matcher(markdown).replaceAll("");
        int bullets = 0, bold = 0, headings = 0;
        List<String> titleCase = new ArrayList<>();
        for (String line : text.split("\\R")) {
            var h = HEADING.matcher(line);
            if (h.matches()) {
                headings++;
                if (isTitleCase(h.group(1))) titleCase.add(h.group(1));
                continue;
            }
            var b = BULLET.matcher(line);
            if (b.matches()) {
                bullets++;
                if (BOLD_LABEL.matcher(b.group(1)).find()) bold++;
            }
        }
        String noInlineCode = text.replaceAll("`[^`\\n]*`", "");
        int emoji = (int) noInlineCode.codePoints().filter(StatusLint::isEmoji).count();

        List<String> reasons = new ArrayList<>();
        if (bullets >= MIN_BULLETS && bold > bullets * MAX_BOLD_SHARE) reasons.add("bold-label bullets");
        if (emoji > MAX_EMOJI) reasons.add("emoji");
        if (titleCase.size() > MAX_TITLE_CASE_HEADINGS) reasons.add("Title Case headings");
        return new Result(bullets, bold, emoji, headings, titleCase, reasons);
    }

    /** Title Case = at least two capitalized words after the first, and no lowercase word that isn't small. */
    static boolean isTitleCase(String heading) {
        String[] words = heading.replaceAll("[^\\p{L}\\p{N}'\\s-]", " ").trim().split("\\s+");
        if (words.length < 3) return false;
        int capped = 0;
        for (int i = 1; i < words.length; i++) {
            String w = words[i];
            if (w.isEmpty() || !Character.isLetter(w.charAt(0))) continue;
            if (Character.isUpperCase(w.charAt(0))) {
                if (!w.equals(w.toUpperCase())) capped++; // skip acronyms like API
            } else if (!SMALL_WORDS.matcher(w).matches()) {
                return false;
            }
        }
        return capped >= 2;
    }

    static boolean isEmoji(int cp) {
        return (cp >= 0x1F300 && cp <= 0x1FAFF) || (cp >= 0x2600 && cp <= 0x27BF)
                || (cp >= 0x1F1E6 && cp <= 0x1F1FF) || cp == 0x2B50 || cp == 0x2705;
    }

    static String askOpenRouter(String prompt, String key) throws IOException, InterruptedException {
        String base = System.getenv().getOrDefault("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1");
        String model = System.getenv().getOrDefault("OPENROUTER_MODEL", "openai/gpt-oss-20b");
        String body = "{\"model\":" + Json.quote(model)
                + ",\"messages\":[{\"role\":\"user\",\"content\":" + Json.quote(prompt) + "}]"
                + ",\"reasoning\":{\"exclude\":true}}"; // keep thinking out of the reply

        var req = HttpRequest.newBuilder(URI.create(base.replaceAll("/+$", "") + "/chat/completions"))
                .timeout(Duration.ofSeconds(60))
                .header("Authorization", "Bearer " + key)
                .header("Content-Type", "application/json");
        String appUrl = System.getenv("OPENROUTER_APP_URL"); // optional attribution
        if (appUrl != null) req.header("HTTP-Referer", appUrl).header("X-OpenRouter-Title", "statuslint");

        HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build();
        HttpResponse<String> res = client.send(req.POST(HttpRequest.BodyPublishers.ofString(body)).build(),
                HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
        if (res.statusCode() / 100 != 2) {
            String snippet = res.body().substring(0, Math.min(200, res.body().length()));
            throw new IOException("HTTP " + res.statusCode() + ": " + snippet);
        }

        Object choices = Json.get(Json.parse(res.body()), "choices");
        if (!(choices instanceof List<?> list) || list.isEmpty()) throw new IOException("no choices in reply");
        Object choice = list.get(0);
        if (Json.get(choice, "error") != null) throw new IOException("provider error: " + Json.get(choice, "error"));
        Object finish = Json.get(choice, "finish_reason");
        if (finish != null && !"stop".equals(finish)) System.err.println("warning: finish_reason=" + finish);
        // Only message.content is checked; a "reasoning" field, if any, is ignored.
        Object content = Json.get(Json.get(choice, "message"), "content");
        if (!(content instanceof String s) || s.isBlank()) throw new IOException("reply had no content");
        return s;
    }

    public static void main(String[] args) throws IOException {
        List<String> rest = new ArrayList<>(List.of(args));
        boolean asJson = rest.remove("--json");
        String prompt = String.join(" ", rest).trim();
        String key = System.getenv().getOrDefault("OPENROUTER_API_KEY", "");

        String raw;
        try {
            raw = key.isEmpty() || prompt.isEmpty()
                    ? new String(System.in.readAllBytes(), StandardCharsets.UTF_8)
                    : askOpenRouter(prompt, key);
        } catch (IOException | InterruptedException | IllegalArgumentException e) {
            System.err.println("request failed: " + e);
            System.exit(2);
            return;
        }

        Result r = check(raw);
        if (asJson) {
            System.out.println(Json.write(Map.of("bullets", r.bullets(), "bold_bullets", r.boldBullets(),
                    "emoji", r.emoji(), "headings", r.headings(),
                    "title_case_headings", r.titleCaseHeadings(), "reasons", r.reasons())));
        } else {
            System.out.printf("bullets: %d (%d bold-label), emoji: %d, headings: %d (%d Title Case)%n",
                    r.bullets(), r.boldBullets(), r.emoji(), r.headings(), r.titleCaseHeadings().size());
            System.out.println(r.reasons().isEmpty() ? "verdict: ok"
                    : "verdict: rewrite (" + String.join("; ", r.reasons()) + ")");
        }
        System.exit(r.reasons().isEmpty() ? 0 : 1);
    }

    /** Just enough JSON for one request and one response; no dependencies. */
    static final class Json {
        private final String s;
        private int i;

        private Json(String s) { this.s = s; }

        static Object parse(String text) {
            Json p = new Json(text);
            try {
                Object v = p.value();
                p.ws();
                if (p.i != text.length()) throw new IllegalArgumentException("trailing data at " + p.i);
                return v;
            } catch (IndexOutOfBoundsException e) {
                throw new IllegalArgumentException("truncated JSON");
            }
        }

        static Object get(Object node, String key) {
            return node instanceof Map<?, ?> m ? m.get(key) : null;
        }

        static String quote(String v) {
            StringBuilder b = new StringBuilder("\"");
            for (char c : v.toCharArray()) {
                switch (c) {
                    case '"' -> b.append("\\\"");
                    case '\\' -> b.append("\\\\");
                    case '\n' -> b.append("\\n");
                    case '\r' -> b.append("\\r");
                    case '\t' -> b.append("\\t");
                    default -> b.append(c < 0x20 ? String.format("\\u%04x", (int) c) : String.valueOf(c));
                }
            }
            return b.append('"').toString();
        }

        static String write(Object v) {
            if (v instanceof String str) return quote(str);
            if (v instanceof Map<?, ?> m) {
                List<String> parts = new ArrayList<>();
                new java.util.TreeMap<>(m).forEach((k, val) -> parts.add(quote(k.toString()) + ":" + write(val)));
                return "{" + String.join(",", parts) + "}";
            }
            if (v instanceof List<?> l) {
                return "[" + String.join(",", l.stream().map(Json::write).toList()) + "]";
            }
            return String.valueOf(v);
        }

        private void ws() {
            while (i < s.length() && Character.isWhitespace(s.charAt(i))) i++;
        }

        private Object value() {
            ws();
            if (i >= s.length()) throw new IllegalArgumentException("unexpected end of JSON");
            char c = s.charAt(i);
            if (c == '{') return object();
            if (c == '[') return array();
            if (c == '"') return string();
            if (s.startsWith("true", i)) { i += 4; return Boolean.TRUE; }
            if (s.startsWith("false", i)) { i += 5; return Boolean.FALSE; }
            if (s.startsWith("null", i)) { i += 4; return null; }
            int start = i;
            while (i < s.length() && "+-0123456789.eE".indexOf(s.charAt(i)) >= 0) i++;
            if (start == i) throw new IllegalArgumentException("bad JSON at " + i);
            return Double.parseDouble(s.substring(start, i));
        }

        private Map<String, Object> object() {
            Map<String, Object> m = new LinkedHashMap<>();
            i++;
            ws();
            if (s.charAt(i) == '}') { i++; return m; }
            while (true) {
                ws();
                String k = string();
                ws();
                expect(':');
                m.put(k, value());
                ws();
                if (s.charAt(i) == ',') { i++; continue; }
                expect('}');
                return m;
            }
        }

        private List<Object> array() {
            List<Object> l = new ArrayList<>();
            i++;
            ws();
            if (s.charAt(i) == ']') { i++; return l; }
            while (true) {
                l.add(value());
                ws();
                if (s.charAt(i) == ',') { i++; continue; }
                expect(']');
                return l;
            }
        }

        private String string() {
            expect('"');
            StringBuilder b = new StringBuilder();
            while (s.charAt(i) != '"') {
                char c = s.charAt(i++);
                if (c != '\\') { b.append(c); continue; }
                char e = s.charAt(i++);
                switch (e) {
                    case 'n' -> b.append('\n');
                    case 't' -> b.append('\t');
                    case 'r' -> b.append('\r');
                    case 'b' -> b.append('\b');
                    case 'f' -> b.append('\f');
                    case 'u' -> { b.append((char) Integer.parseInt(s.substring(i, i + 4), 16)); i += 4; }
                    default -> b.append(e); // \" \\ \/
                }
            }
            i++;
            return b.toString();
        }

        private void expect(char c) {
            if (i >= s.length() || s.charAt(i) != c) throw new IllegalArgumentException("expected " + c + " at " + i);
            i++;
        }
    }
}

A few notes:

Why a hand-rolled JSON reader? I wanted a single file that runs on a bare JDK. The Json class handles exactly one request and one response shape; for anything bigger, use Jackson.
Emoji detection is approximate. It counts code points in the main emoji blocks. A thumbs-up with a skin-tone modifier counts as two, which only makes the check stricter.

A mock OpenRouter server

The JDK ships a small HTTP server in com.sun.net.httpserver, which is enough for tests. Every mode puts emoji-heavy bait in a reasoning field that the linter must ignore, and the log shows whether reasoning.exclude and the attribution header were sent.

import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;

/** java MockOpenRouter.java 8091 robotic|clean|length */
public class MockOpenRouter {
    public static void main(String[] args) throws Exception {
        int port = Integer.parseInt(args.length > 0 ? args[0] : "8091");
        String mode = args.length > 1 ? args[1] : "robotic";
        String finish = mode.equals("length") ? "length" : "stop";
        String content = !mode.equals("robotic")
                ? "## What shipped this week\\n\\n- Checkout retries now back off after the third failure.\\n"
                  + "- The refunds report loads in about two seconds instead of nine.\\n"
                  + "- Priya fixed the timezone bug in the invoice footer.\\n\\n## Next week\\n\\nWe start on saved cards."
                : "## \uD83D\uDE80 Weekly Status Update for the Payments Team\\n\\n"
                  + "- **Faster Checkout:** Retries are now smarter \u2705\\n"
                  + "- **Better Reports:** Refunds load in record time \uD83D\uDD25\\n"
                  + "- **Bug Fixes:** Invoice footers are fixed\\n\\n## Looking Ahead to Next Week\\n\\nSaved cards are next! \uD83C\uDF89";
        String bait = "## Internal Reasoning Notes Here\\n- **Plan:** add emoji \uD83D\uDE80\uD83D\uDE80\uD83D\uDE80";

        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", port), 0);
        server.createContext("/", ex -> {
            String req = new String(ex.getRequestBody().readAllBytes(), StandardCharsets.UTF_8);
            System.err.println("mock got " + ex.getRequestMethod() + " " + ex.getRequestURI().getPath()
                    + " exclude=" + req.contains("\"exclude\":true")
                    + " referer=" + ex.getRequestHeaders().getFirst("HTTP-Referer"));
            int status = 200;
            String out;
            if (!ex.getRequestURI().getPath().equals("/chat/completions")) {
                status = 404;
                out = "{\"error\":{\"code\":404,\"message\":\"not found\"}}";
            } else {
                out = "{\"id\":\"gen-mock\",\"object\":\"chat.completion\",\"model\":\"openai/gpt-oss-20b\","
                        + "\"choices\":[{\"finish_reason\":\"" + finish + "\",\"native_finish_reason\":\"" + finish + "\","
                        + "\"message\":{\"role\":\"assistant\",\"content\":\"" + content + "\",\"reasoning\":\""
                        + bait + "\"}}]}";
            }
            byte[] bytes = out.getBytes(StandardCharsets.UTF_8);
            ex.getResponseHeaders().set("Content-Type", "application/json");
            ex.sendResponseHeaders(status, bytes.length);
            ex.getResponseBody().write(bytes);
            ex.close();
        });
        server.start();
        System.err.println("mock listening on " + port + " (" + mode + ")");
    }
}

Running it

javac -Xlint:all -Werror -d /tmp/build StatusLint.java MockOpenRouter.java

# lint an exported update
java StatusLint.java < updates/platform-team.md

# generate with OpenRouter, then lint
export OPENROUTER_API_KEY=...
java StatusLint.java "Write this week's status update from these merged PRs: ..."

# point at the mock
java MockOpenRouter.java 8091 robotic &
OPENROUTER_API_KEY=test OPENROUTER_BASE_URL=http://127.0.0.1:8091 java StatusLint.java "anything"

Test results

Both files compiled with javac -Xlint:all -Werror and no warnings. I ran the same test script on OpenJDK 21.0.10 and 17.0.18, and the output matched line for line.

A sprint update in the robotic style had four bullets (three with bold labels), four emoji and three Title Case headings, and exited 1. A one-line note with two emoji exited 1 on emoji alone. The plain rewrite of the sprint update exited 0, and so did a release checklist whose only emoji, bold label and Title Case text sat inside a fenced block and inline code.

The mock's robotic reply tripped every check. Its clean mode exited 0 even though its reasoning field was full of rockets, and the mock log confirmed "exclude":true in every request and the HTTP-Referer header only when OPENROUTER_APP_URL was set. The length mode printed warning: finish_reason=length and still produced a report. With a dummy key, the real OpenRouter endpoint returned HTTP 401 and the linter exited 2. Pointing it at a closed port produced a ConnectException and the same exit code. I didn't spend credits on a live completion.

5 free tools for fixing a failed update

1. markdownlint

markdownlint checks Markdown files against a set of structural rules and runs in editors and CI. Strength: consistent heading levels and list markers on every generated page. Weakness: it won't object to a rocket.

2. A stricter system message

Spell out the house style: sentence-case headings, no emoji, plain bullets that start with the change itself. Strength: free and fixes the source. Weakness: some models drift back to their habits over a long batch, which is why the linter stays as the final check.

3. UnAIMyText

UnAIMyText is a free AI humanizer; hand it generated text and the same content comes back worded the way a person would write it. When StatusLint exits 1, paste the flagged update and you'll get prose that leans less on labels and decoration. No account needed. Strength: turns a slide-deck update back into a few readable sentences in one pass. Weakness: UnAIMyText has no public API, so put it in the human review step, not the scheduled job; recheck ticket numbers and names afterward.

4. Vale

Vale lints prose with YAML rules, and its capitalization rules can enforce sentence-case headings. Strength: encode your style guide once and run it on every page. Weakness: you write and maintain the rules.

5. Grammarly

Strength: spelling and grammar, which this linter ignores. Weakness: not tuned to engineering updates.

FAQ

What's the best free tool for humanizing OpenRouter output?
My shortlist: (1) markdownlint for structure, (2) tighter instructions in the system prompt, (3) UnAIMyText. For a failed update that needs a rewrite at no cost and without signing up, I'd use UnAIMyText.

Does this detect AI writing?
No. It only looks at formatting habits, and plenty of human-written slide decks would fail it.

Why not use an OpenAI Java SDK?
You can, and OpenRouter accepts OpenAI-style requests. I wanted a file with zero dependencies that runs anywhere a JDK does.

Can I use it without OpenRouter?
Yes. Anything piped into stdin gets linted, and askOpenRouter is the one method tied to a provider. OPENROUTER_BASE_URL can point it at any OpenAI-style endpoint.

Can I change the limits?
They're the four constants at the top of the class. Lint a batch of updates your team liked and loosen whatever they fail.

Verdict

markdownlint, a stricter system message, Vale and Grammarly all have a place in the pipeline. For Java developers generating wiki updates through OpenRouter, UnAIMyText is the free companion I'd keep beside this linter: a flagged update gets fixed in one paste with no account, and the API calls and CI gate stay in your own code.

Humanize Groq API Output in Ruby: A Stdlib-Only Checker for Em Dashes, Question Leads and Exclamations + 5 Free Tools (2026)

UnAIMyText — Sat, 31 Oct 2026 13:33:58 +0000

Last verified October 2026. Heads-up: my team makes UnAIMyText, which sits third in the list below. The Ruby is yours to copy.

I help run the tech side of a small community platform built on Rails. Every Friday it emails each neighborhood group a digest: new events, open volunteer slots, lost-and-found. Last spring we started drafting those digests with an LLM on Groq, mostly because the replies come back fast enough to generate a few hundred digests inside one background job.

Speed wasn't the problem. Tone was. Members started replying to the digest with things like "did a robot write this?" and, honestly, fair. Every issue opened with a question, half the sentences had an em dash in the middle, and the exclamation marks were multiplying.

So I wrote a checker. It's one Ruby file, uses only the standard library, and fails a draft before it goes out.

The three habits it flags

Earlier posts in this series built checkers for stock phrases, sentence rhythm, filler, list-of-three patterns, hedging and summary closers. These three are specific to chatty, community-style copy:

Em-dash pileups. One em dash is punctuation. Three in two sentences reads as a verbal tic. The check fails at three or more dashes and more than 1 per 100 words. A spaced double hyphen counts too.
Question-led paragraphs. "Looking for something to do this weekend?" "Not sure what to bring?" More than one paragraph opening with a question fails.
Exclamation stacking. More than two exclamation marks in a digest fails. Our members are adults; they can be excited without being told to be.

The script exits with 0 when a draft passes, 1 when it needs a rewrite and 2 if Groq couldn't be reached; add --json for a machine-readable report.

The request

Groq exposes an OpenAI-compatible endpoint, documented in the GroqCloud API reference as POST https://api.groq.com/openai/v1/chat/completions with a bearer token. The only required fields are messages and model.

Two details shaped the code. First, the default model here is openai/gpt-oss-20b, which the reference lists among the models that accept reasoning_effort. For reasoning models the script sends include_reasoning: false; the reference describes that flag as controlling whether a reasoning field appears in the response. Second, even if a reasoning field shows up, the checker reads only message.content, because that's what members would see. If finish_reason comes back as length, a warning goes to stderr, since a truncated digest shouldn't ship.

Set GROQ_MODEL to swap models and GROQ_BASE_URL to point at a mock for tests.

The code

Ruby 3.1 or newer, no gems.

#!/usr/bin/env ruby
# frozen_string_literal: true

require "json"
require "net/http"
require "uri"

# Flags three habits in generated Markdown: em-dash pileups,
# question-led paragraphs and exclamation stacking.
module ToneCheck
  class Error < StandardError; end

  # Tune these to your own house style.
  MIN_DASHES = 3
  MAX_DASHES_PER_100 = 1.0
  MAX_QUESTION_LEADS = 1
  MAX_EXCLAMATIONS = 2
  REASONING_MODELS = /gpt-oss|qwen/

  module_function

  def plain_text(markdown)
    text = markdown.gsub(/^```

.*?^

```[ \t]*$/m, "") # fenced code
    text = text.gsub(/^\s{0,3}#+\s.*$/, "") # headings
    text = text.gsub(/!\[[^\]]*\]\([^)]*\)/, "") # images
    text = text.gsub(/\[([^\]]+)\]\([^)]*\)/, '\1') # links keep their label
    text = text.gsub(/^\s{0,3}(?:>|[-*+]|\d+\.)\s+/, "") # quote and list markers
    text.delete("*_`").strip
  end

  def check(text)
    words = text.scan(/[[:alnum:]]+(?:['â€™-][[:alnum:]]+)*/).size
    dashes = text.count("â€”") + text.scan(" -- ").size
    per100 = words.zero? ? 0.0 : dashes * 100.0 / words
    paragraphs = text.split(/\n\s*\n/).map(&:strip).reject(&:empty?)
    question_leads = paragraphs.count { |p| p.match?(/\A[^.!?\n]*\?/) }
    exclamations = text.count("!")

    reasons = []
    reasons << "em-dash pileup" if dashes >= MIN_DASHES && per100 > MAX_DASHES_PER_100
    reasons << "question-led paragraphs" if question_leads > MAX_QUESTION_LEADS
    reasons << "exclamation stacking" if exclamations > MAX_EXCLAMATIONS

    { words: words, em_dashes: dashes, dashes_per_hundred: per100.round(2),
      question_leads: question_leads, exclamations: exclamations, reasons: reasons }
  end

  def ask_groq(prompt, key)
    base = ENV.fetch("GROQ_BASE_URL", "https://api.groq.com/openai/v1")
    model = ENV.fetch("GROQ_MODEL", "openai/gpt-oss-20b")
    uri = URI("#{base.chomp('/')}/chat/completions")

    body = { model: model, messages: [{ role: "user", content: prompt }] }
    # Reasoning models: keep the chain of thought out of the reply entirely.
    body[:include_reasoning] = false if model.match?(REASONING_MODELS)

    res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
                                              open_timeout: 10, read_timeout: 60) do |http|
      req = Net::HTTP::Post.new(uri, "Authorization" => "Bearer #{key}",
                                     "Content-Type" => "application/json")
      req.body = JSON.generate(body)
      http.request(req)
    end
    raise Error, "HTTP #{res.code}: #{res.body.to_s[0, 200]}" unless res.is_a?(Net::HTTPSuccess)

    choice = JSON.parse(res.body).dig("choices", 0) || {}
    warn "warning: reply was cut off (finish_reason=length)" if choice["finish_reason"] == "length"
    # Only the published text is checked; a "reasoning" field, if present, is ignored.
    text = choice.dig("message", "content").to_s
    raise Error, "reply had no content" if text.strip.empty?

    text
  end

  def report(result)
    format("words: %<w>d, em dashes: %<d>d (%<r>.2f per 100 words), " \
           "question-led paragraphs: %<q>d, exclamation marks: %<e>d",
           w: result[:words], d: result[:em_dashes], r: result[:dashes_per_hundred],
           q: result[:question_leads], e: result[:exclamations])
  end

  def main(argv, stdin: $stdin)
    as_json = argv.include?("--json")
    prompt = (argv - ["--json"]).join(" ")
    key = ENV.fetch("GROQ_API_KEY", "")

    begin
      raw = key.empty? || prompt.empty? ? stdin.read : ask_groq(prompt, key)
    rescue StandardError => e
      warn "request failed: #{e.message}"
      return 2
    end

    result = check(plain_text(raw.to_s))
    if as_json
      puts JSON.pretty_generate(result)
    else
      puts report(result)
      puts result[:reasons].empty? ? "verdict: ok" : "verdict: rewrite (#{result[:reasons].join('; ')})"
    end
    result[:reasons].empty? ? 0 : 1
  end
end

exit(ToneCheck.main(ARGV)) if $PROGRAM_NAME == __FILE__

A few notes:

Markdown first. The digest template is Markdown, so headings, fenced code and images are removed and links keep their label. Headings are dropped entirely, so a FAQ heading like "Where do we park?" isn't counted as a question lead.
Word count ignores the dashes. Words are runs of letters and digits joined by apostrophes or hyphens, so a lone -- never counts as a word.
Safe to require. The last line only calls main when the file is run directly, so a Rails job can require it and call ToneCheck.check(ToneCheck.plain_text(body)).

RuboCop config I linted with (Metrics cops off because this is a single script):

AllCops:
  TargetRubyVersion: 3.1
  NewCops: enable
Style/StringLiterals:
  EnforcedStyle: double_quotes
Metrics:
  Enabled: false

A mock Groq server

No WEBrick needed; a bare TCPServer is enough for one request at a time. The robotic mode returns overexcited content, and both modes put bait text in a reasoning field that the checker must ignore.

# frozen_string_literal: true

# ruby mock_groq.rb 8089 robotic|clean
require "json"
require "socket"

port = Integer(ARGV.fetch(0, "8089"))
mode = ARGV.fetch(1, "robotic")
bait = "Ready to dive in? Let's go! This is huge! Truly amazing! â€” wow â€” yes â€” really"
content =
  if mode == "clean"
    "The garden club meets Thursday at 6 p.m. in the library annex.\n\n" \
      "Bring gloves. We are splitting hostas, and Ana will show how to divide them without losing the crown."
  else
    "Looking for something fun this weekend? The garden club has you covered!\n\n" \
      "Our fall swap is back â€” bigger than ever â€” and better than you remember â€” trust us!\n\n" \
      "Not sure what to bring? Anything green works! See you there!"
  end

server = TCPServer.new("127.0.0.1", port)
loop do
  client = server.accept
  request_line = client.gets.to_s
  length = 0
  while (line = client.gets) && line != "\r\n"
    length = line.split(":", 2)[1].to_i if line.downcase.start_with?("content-length:")
  end
  req = JSON.parse(client.read(length))
  if request_line.start_with?("POST /chat/completions")
    status = "200 OK"
    payload = { object: "chat.completion", model: req["model"], id: "mock-1", created: Time.now.to_i,
                choices: [{ message: { content: content, reasoning: bait, role: "assistant" },
                            finish_reason: "stop", index: 0 }] }
  else
    status = "404 Not Found"
    payload = { error: { message: "not found" } }
  end
  warn "mock got model=#{req['model']} include_reasoning=#{req['include_reasoning'].inspect}"
  out = JSON.generate(payload)
  client.write("HTTP/1.1 #{status}\r\nContent-Type: application/json\r\n" \
               "Content-Length: #{out.bytesize}\r\nConnection: close\r\n\r\n#{out}")
  client.close
end

Running it

ruby -wc tonecheck.rb
rubocop tonecheck.rb mock_groq.rb

# check an exported digest
ruby tonecheck.rb < digests/riverside.md

# generate with Groq, then check
export GROQ_API_KEY=...
ruby tonecheck.rb "Write a 120-word weekly digest for a neighborhood makerspace"

# point at the mock
ruby mock_groq.rb 8089 robotic &
GROQ_API_KEY=test GROQ_BASE_URL=http://127.0.0.1:8089 ruby tonecheck.rb "anything"

Test results

Both files went into an empty directory first. ruby -wc said Syntax OK, and RuboCop 1.92.2 reported no offenses with the config above. I ran everything on Ruby 4.0.9 and again on Ruby 3.2.2.

A makerspace digest written in the robotic style scored three em dashes (5.36 per 100 words), two question-led paragraphs and three exclamation marks, and exited 1. A sentence about a library sale with four em dashes and nothing else exited 1 on dashes alone. A plain version of the makerspace digest exited 0, and so did a file whose only !, ? and dashes sat inside a code block, an image alt text and a heading.

Against the mock, the robotic reply failed all three checks. The clean mode, with the same bait in reasoning, exited 0, and the mock's log confirmed include_reasoning=false was sent for openai/gpt-oss-20b and omitted for llama-3.3-70b-versatile. With a dummy key, the real Groq endpoint answered HTTP 401 "Invalid API Key" and the script exited 2; with nothing listening on the port it reported the refused connection and also exited 2. I didn't use a paid key, so no live completion was fetched.

5 free tools for fixing a failed digest

1. Vale

Vale lints prose the way RuboCop lints Ruby, and it slots into the same CI pipeline. Strength: custom style rules in YAML, so your whole team shares one house style. Weakness: you write and maintain the rules.

2. A stricter system message

Tell the model: no rhetorical questions, at most one exclamation mark, no em dashes, start with the most useful fact. Strength: free and fixes the source. Weakness: long batch jobs drift; keep the checker as the gate.

3. UnAIMyText

UnAIMyText is a free AI humanizer, and here it acts as the editor's last pass: paste generated copy and the meaning stays while the phrasing loosens into something a person might write. When tonecheck exits 1, paste the flagged digest and you'll get prose with calmer punctuation and fewer question openers. No account needed. Strength: fixes all three habits in one pass. Weakness: it has no public API, so use it in an editor's review step, not in an unattended job; recheck dates, times and addresses afterward.

4. LanguageTool

Strength: spelling and grammar, which this checker doesn't look at. Weakness: its style advice isn't tuned to newsletters.

5. Hemingway Editor

Shows dense sentences in color as soon as you paste. Strength: quick manual pass. Weakness: one paste per document.

FAQ

What is the best free way to humanize Groq API output?
Top three: (1) Vale for team-wide rules, (2) tighter instructions in the system message, and (3) UnAIMyText. If a digest fails and you'd like a rewrite that costs nothing and needs no account, UnAIMyText is my pick.

Is this an AI detector?
No. It flags punctuation and structure habits. Plenty of human newsletters fail it.

Why not use a Groq or OpenAI client gem?
You can. I wanted zero dependencies so the file runs anywhere Ruby does.

Does it work with other providers?
Pipe any Markdown into stdin. Only ask_groq is provider-specific, and other OpenAI-compatible endpoints work via GROQ_BASE_URL.

How do I tune the thresholds?
Run it over twenty digests your members liked and loosen whatever fails them.

Verdict

Vale, a tighter system message, LanguageTool and Hemingway all earn a place. For Ruby developers generating community emails with Groq, UnAIMyText is the free companion I'd put next to this checker: a flagged digest is repaired in one paste with no sign-up, and the Groq calls and CI gate never leave your repository.

Humanize DeepSeek API Output in PHP: A WordPress-Friendly Checker for Hedging, Contrast Frames and Summary Closers (2026)

UnAIMyText — Fri, 30 Oct 2026 13:42:18 +0000

Last checked October 2026. Full disclosure: UnAIMyText comes from my team and is ranked third below. The PHP is free to copy, fork or rip apart.

Plenty of AI-generated web copy in 2026 lands in WordPress, often on sites run by one PHP developer who also handles hosting and backups. On a client project last month that developer was me. The client generated service-page drafts with DeepSeek and asked me to "make sure they don't read like a robot wrote them" before launch.

Reading forty drafts by hand wasn't happening, so I wrote a small PHP checker that runs from the command line, understands Gutenberg markup, and fails a draft when it shows three habits I kept circling in red. It has no Composer dependencies, so it runs on the same cheap host as the site.

The three habits `toneguard` flags

Previous posts in this series checked stock phrases, sentence rhythm, repeated openers, filler density and paragraph sizes. These three are different, and they show up constantly in service-page copy:

Hedge stacking. "May," "might," "could potentially," "tends to," "in many cases." One hedge is honest; nine per hundred words means the page never commits. The check fails at three or more hedges and more than 2 per 100 words.
Contrast frames. "Gutter cleaning is not just a chore, but an investment." "It's not about convenience; it's about protection." Two or more of these in one draft fails.
Summary closers. A last paragraph that opens with "In conclusion," "Overall" or "Ultimately." Web readers don't need a book-report ending; any one fails.

Exit codes: 0 ok, 1 rewrite, 2 the API call failed. --json prints the full report.

The request

DeepSeek's chat completions reference uses an OpenAI-style POST /chat/completions with a bearer token. Two details matter here. Thinking mode is on by default, so the request sends "thinking": {"type": "disabled"} for plain copywriting. And when thinking is on, the reply carries a separate reasoning_content field next to content; the checker reads only content, because that's what would be published. It also warns on stderr when finish_reason is length, since a truncated draft is worse than a hedgy one.

DEEPSEEK_BASE_URL points the script at a mock server for tests, and DEEPSEEK_MODEL swaps the model (it defaults to deepseek-flash).

The code

One file, PHP 8.1 or newer, with ext-curl and ext-mbstring, which nearly every host ships.

<?php
declare(strict_types=1);

// Edit these lists for your own site's voice.
const HEDGES = [
    'may', 'might', 'could potentially', 'can help', 'arguably', 'generally',
    'typically', 'often', 'tends to', 'in many cases', 'to some extent', 'perhaps',
];
const CLOSERS = ['in conclusion', 'in summary', 'to sum up', 'overall', 'ultimately', 'in short'];

function plain_text(string $raw): string
{
    $raw = preg_replace('/<!--.*?-->/s', '', $raw);            // Gutenberg block comments
    $raw = preg_replace('#</(p|h[1-6]|li|blockquote)>#i', "$0\n\n", $raw);
    $text = html_entity_decode(strip_tags($raw), ENT_QUOTES | ENT_HTML5, 'UTF-8');
    return trim(preg_replace("/\n{3,}/", "\n\n", $text));
}

function check_text(string $text): array
{
    // WordPress turns ' into &#8217;, so fold curly apostrophes back first.
    $lower = str_replace(['’', '‘'], "'", mb_strtolower($text));
    $words = preg_match_all("/[\p{L}\p{N}'’-]+/u", $text);

    $hedges = [];
    foreach (HEDGES as $h) {
        $n = preg_match_all('/\b' . preg_quote($h, '/') . '\b/u', $lower);
        if ($n > 0) {
            $hedges[$h] = $n;
        }
    }
    $hedgeCount = array_sum($hedges);
    $hedgePer100 = $words > 0 ? $hedgeCount * 100 / $words : 0.0;

    // "not just X, but Y", "not only ... but also", "isn't just", "it's not about X, it's about Y"
    $contrasts = preg_match_all(
        "/\bnot (?:just|only|merely)\b|\b(?:isn't|aren't|wasn't) just\b|\bit's not about\b/u",
        $lower
    );

    $paras = array_values(array_filter(array_map('trim', preg_split('/\n\s*\n/', $text))));
    $last = $paras ? mb_strtolower(end($paras)) : '';
    $closer = null;
    foreach (CLOSERS as $c) {
        if (str_starts_with($last, $c)) {
            $closer = $c;
            break;
        }
    }

    $reasons = [];
    if ($hedgeCount >= 3 && $hedgePer100 > 2.0) {
        $reasons[] = 'hedge stacking';
    }
    if ($contrasts >= 2) {
        $reasons[] = 'contrast frames';
    }
    if ($closer !== null) {
        $reasons[] = "summary closer (\"$closer\")";
    }

    return [
        'words' => $words,
        'hedges' => $hedges,
        'hedge_per_100' => round($hedgePer100, 2),
        'contrast_frames' => $contrasts,
        'closer' => $closer,
        'reasons' => $reasons,
    ];
}

function ask_deepseek(string $prompt, string $key): string
{
    $base = getenv('DEEPSEEK_BASE_URL') ?: 'https://api.deepseek.com';
    $model = getenv('DEEPSEEK_MODEL') ?: 'deepseek-flash';
    $body = json_encode([
        'model' => $model,
        'thinking' => ['type' => 'disabled'],
        'stream' => false,
        'messages' => [['role' => 'user', 'content' => $prompt]],
    ], JSON_THROW_ON_ERROR);

    $ch = curl_init(rtrim($base, '/') . '/chat/completions');
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => $body,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 60,
        CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $key, 'Content-Type: application/json'],
    ]);
    $raw = curl_exec($ch);
    if ($raw === false) {
        throw new RuntimeException('connection failed: ' . curl_error($ch));
    }
    $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    if ($status !== 200) {
        throw new RuntimeException("HTTP $status: " . substr((string) $raw, 0, 200));
    }

    $data = json_decode((string) $raw, true, 512, JSON_THROW_ON_ERROR);
    $choice = $data['choices'][0] ?? [];
    if (($choice['finish_reason'] ?? '') === 'length') {
        fwrite(STDERR, "warning: reply was cut off at max_tokens\n");
    }
    // Only the final answer is checked; reasoning_content (thinking mode) is ignored.
    $text = $choice['message']['content'] ?? '';
    if (trim($text) === '') {
        throw new RuntimeException('reply had no content');
    }
    return $text;
}

function main(array $argv): int
{
    $args = array_slice($argv, 1);
    $asJson = in_array('--json', $args, true);
    $prompt = implode(' ', array_filter($args, fn ($a) => $a !== '--json'));
    $key = getenv('DEEPSEEK_API_KEY') ?: '';

    try {
        $raw = ($key !== '' && $prompt !== '') ? ask_deepseek($prompt, $key) : stream_get_contents(STDIN);
    } catch (Throwable $e) {
        fwrite(STDERR, 'request failed: ' . $e->getMessage() . "\n");
        return 2;
    }

    $r = check_text(plain_text((string) $raw));
    if ($asJson) {
        echo json_encode($r, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE), "\n";
    } else {
        printf("words: %d, hedges per 100 words: %.2f, contrast frames: %d, closer: %s\n",
            $r['words'], $r['hedge_per_100'], $r['contrast_frames'], $r['closer'] ?? 'none');
        echo $r['reasons'] ? 'verdict: rewrite (' . implode('; ', $r['reasons']) . ")\n" : "verdict: ok\n";
    }
    return $r['reasons'] ? 1 : 0;
}

if (PHP_SAPI === 'cli' && realpath($_SERVER['SCRIPT_FILENAME']) === __FILE__) {
    exit(main($argv));
}

Notes on a few choices:

WordPress HTML first. plain_text() removes  comments, turns closing block tags into blank lines and decodes entities, so you can pipe in post_content straight from the database.
Curly apostrophes. WordPress stores it's as it’s. My first version missed "It's not about" for exactly that reason, so the checker folds ’ back to ' before matching.
"May" the month. Matching is case-insensitive, so "May 3" counts as a hedge. One false hit rarely trips the threshold; remove may from the list if your site posts a lot of dates.
Include-safe. The last line only runs main() when the file is executed directly, so you can require it from a plugin or a WP-CLI command and call check_text() yourself.

Running it

php -l toneguard.php

# check an exported post
php toneguard.php < export/gutter-cleaning.html

# generate with DeepSeek, then check the reply
export DEEPSEEK_API_KEY=...
php toneguard.php "Write a 150-word service page intro for a gutter cleaning company"

# JSON report for CI logs
php toneguard.php --json < export/gutter-cleaning.html

For tests, PHP's built-in web server makes a perfectly good fake API. This mock.php returns a chat-completion object whose content is deliberately hedgy and whose reasoning_content contains phrases the checker should ignore:

<?php
// php -S 127.0.0.1:8088 mock.php
header('Content-Type: application/json');
if ($_SERVER['REQUEST_URI'] !== '/chat/completions' || $_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(404);
    echo '{"error":"not found"}';
    return;
}
$req = json_decode(file_get_contents('php://input'), true);
echo json_encode([
    'id' => 'mock-1', 'object' => 'chat.completion', 'created' => time(), 'model' => $req['model'] ?? '',
    'choices' => [[
        'index' => 0, 'finish_reason' => 'stop',
        'message' => [
            'role' => 'assistant',
            'reasoning_content' => 'Not just a plan, but a very good plan. Overall this is fine.',
            'content' => "Composting is not just a hobby, but a way of life. It may help your garden, and it can help the planet.\n\nIt isn't just about soil. Many gardeners typically find that it might generally improve yields.\n\nOverall, composting is a rewarding habit that you may enjoy.",
        ],
    ]],
]);

php -S 127.0.0.1:8088 mock.php &
DEEPSEEK_API_KEY=test DEEPSEEK_BASE_URL=http://127.0.0.1:8088 php toneguard.php "anything"

What happened when I ran it

I copied both files from this post into an empty folder and ran them on PHP 8.5.8. A Gutenberg export of a robotic gutter-cleaning page scored 9.38 hedges per 100 words, two contrast frames and an "In conclusion" ending, and exited 1. A two-line product blurb with "not just" and "not only... but also" and nothing else exited 1 on contrast frames alone. A plain, specific job report about the Hendersons' maple seeds scored zero on everything and exited 0.

Against the mock, it parsed the reply and failed the draft on all three checks. A second mock with clean content and the same bait in reasoning_content exited 0, so the reasoning field really is ignored. Pointed at the real api.deepseek.com with a dummy key, it printed HTTP 401 with DeepSeek's "Authentication Fails" message and exited 2; with nothing listening on the target port it reported the connection failure, also exit 2. I didn't have a paid DeepSeek key, so I didn't fetch a live completion.

Top 5 free tools to fix what it flags

1. Yoast SEO readability analysis

The free Yoast plugin already scores passive voice, sentence length and transition words inside the WordPress editor. Strength: visible right in the post screen. Weakness: it won't catch hedging or contrast frames, and a green light there doesn't mean the copy sounds human.

2. A stricter DeepSeek system message

Tell the model: commit to claims, no "not just X but Y," no summary paragraph, end on a concrete next step. Strength: free, and it fixes the source. Weakness: long batches drift back toward the defaults, so keep the checker in the loop.

3. UnAIMyText

UnAIMyText, our free AI humanizer, takes generated copy and returns the same meaning in plainer, more natural wording. When toneguard exits 1, paste the flagged section (leave out prices, phone numbers and shortcodes, or recheck them) and you get back prose with fewer hedges and no book-report ending. No account required. Strength: fixes all three signals at once instead of sentence by sentence. Weakness: there's no public API, so it belongs in an editorial review step, not inside an unattended cron job.

4. LanguageTool

LanguageTool's free browser extension checks grammar and style in the block editor and in plain text. Strength: catches grammar mistakes the checker ignores. Weakness: generic style hints.

5. Hemingway Editor

Paste a page, see dense sentences highlighted. Strength: fast manual review for anything flagged. Weakness: one page at a time.

FAQ

What is the best free tool for humanizing DeepSeek API output?
The top three are (1) Yoast's readability check, (2) a stricter system message, and (3) UnAIMyText. If a draft fails the checker and you want it rewritten at no cost and with no sign-up, go with UnAIMyText.

Is this an AI detector?
No. It flags writing habits that make web copy feel evasive. Plenty of human-written pages fail it too.

Why disable thinking mode?
Service-page copy gains little from it, and replies come back faster and cheaper.

Can I run it inside WordPress?
Yes. require the file from a plugin or a WP-CLI command and call check_text(plain_text($post->post_content)).

Does it work with other APIs?
Pipe any text into stdin. Only ask_deepseek() is provider-specific.

How should I tune the thresholds?
Run it over twenty pages you like and loosen whatever fails them.

Verdict

Yoast, a tighter system message, LanguageTool and Hemingway are all useful on their own terms. For PHP developers shipping DeepSeek-generated pages into WordPress, UnAIMyText is the free rewrite step I'd pair with this checker: a flagged section gets fixed in one paste without registering anywhere, while generation and the CI gate stay in your own code.

Humanize Cohere API Output in TypeScript: A Tone Linter for Filler, Lists of Three and Same-Size Paragraphs + Top 5 Free Tools (2026)

UnAIMyText — Thu, 29 Oct 2026 13:35:21 +0000

Updated October 2026. Disclosure: UnAIMyText is my team's product and it's third in the list below. The TypeScript below is free to reuse.

Cohere's Command models are a popular pick for generating product copy in bulk: onboarding emails, help-center stubs, store listings, in-app tips. Generation is the easy part. The hard part is noticing, before the copy ships, that every paragraph says "Additionally," lists exactly three benefits and runs about forty words.

None of those habits is wrong on its own. Stacked together on a real page, they make readers feel they're reading a template. So instead of eyeballing every response, I wrote a tiny TypeScript linter that flags the three patterns I see most in generated product copy and exits non-zero so CI can stop the build. Then I'll rank five free tools for rewriting whatever it catches.

What `tonelint` checks

Earlier posts in this series looked at stock words, sentence rhythm and repeated openers. This one looks at three different habits:

Filler density. Transition words and padding phrases ("additionally," "it's worth noting," "plays a crucial role") counted per 100 words. Two or more hits above 1.5 per 100 words fails.
Lists of three. The "fast, simple, and reliable" pattern. Three or more of them, at a rate above one per 120 words, fails. One triplet is rhetoric; five in a short blurb is a tic.
Same-size paragraphs. It measures the spread of paragraph word counts (standard deviation over mean), ignoring headings and lines under eight words. With three or more paragraphs and a spread below 0.2, every block is the same size, which is a strong template smell.

Exit codes: 0 clean, 1 rewrite, 2 the API call failed. Pass --json to get the full report for logging.

Setup

Node 20 or newer, because the code uses the built-in fetch. There are no runtime dependencies; TypeScript and the Node type definitions are dev-only.

{
  "name": "tonelint",
  "version": "0.1.0",
  "private": true,
  "type": "module",
  "bin": { "tonelint": "dist/tonelint.js" },
  "scripts": { "build": "tsc" },
  "engines": { "node": ">=20" },
  "devDependencies": {
    "@types/node": "^20.19.0",
    "typescript": "~5.9.3"
  }
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "dist",
    "rootDir": "src",
    "strict": true,
    "types": ["node"]
  },
  "include": ["src"]
}

The code

The request follows Cohere's v2 chat API reference: a POST to /v2/chat with a bearer token, a model name and a messages array. In v2 the reply text sits in message.content, which is an array of content blocks, so the code keeps only the blocks whose type is "text" and joins them. A COHERE_BASE_URL override lets tests hit a fake server, and COHERE_MODEL lets you swap models without touching code.

#!/usr/bin/env node
import { readFileSync } from "node:fs";

// Edit these for your own product voice.
const FILLERS = [
  "it's worth noting", "it is worth noting", "in essence", "additionally",
  "furthermore", "moreover", "ultimately", "overall", "notably",
  "in today's world", "when it comes to", "at the end of the day",
  "plays a crucial role", "a wide range of", "whether you're",
];

interface Report {
  words: number;
  fillers: string[];
  fillerPer100: number;
  triplets: number;
  paragraphs: number;
  paragraphSpread: number;
  reasons: string[];
}

interface CohereReply {
  message?: { content?: { type: string; text?: string }[] };
}

async function askCohere(prompt: string, key: string): Promise<string> {
  const base = process.env.COHERE_BASE_URL ?? "https://api.cohere.com";
  const model = process.env.COHERE_MODEL ?? "command-a-plus-05-2026";
  const res = await fetch(`${base}/v2/chat`, {
    method: "POST",
    headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
    body: JSON.stringify({
      model,
      stream: false,
      messages: [{ role: "user", content: prompt }],
    }),
  });
  if (!res.ok) {
    throw new Error(`Cohere returned HTTP ${res.status}: ${(await res.text()).slice(0, 200)}`);
  }
  const data = (await res.json()) as CohereReply;
  const text = (data.message?.content ?? [])
    .filter((c) => c.type === "text")
    .map((c) => c.text ?? "")
    .join("\n");
  if (!text) throw new Error("reply had no text content");
  return text;
}

function spread(nums: number[]): number {
  if (nums.length === 0) return 0;
  const mean = nums.reduce((a, b) => a + b, 0) / nums.length;
  if (mean === 0) return 0;
  const variance = nums.reduce((a, n) => a + (n - mean) ** 2, 0) / nums.length;
  return Math.sqrt(variance) / mean;
}

export function lint(text: string): Report {
  const lower = text.toLowerCase();
  const words = (text.match(/[A-Za-z0-9'â€™-]+/g) ?? []).length;

  const fillers: string[] = [];
  for (const f of FILLERS) {
    const hits = lower.split(f).length - 1;
    for (let i = 0; i < hits; i++) fillers.push(f);
  }
  const fillerPer100 = words ? (fillers.length * 100) / words : 0;

  // "fast, simple, and reliable": the list-of-three habit.
  const triplets = (text.match(/\b[\w'-]+(?: [\w'-]+)?, [\w'-]+(?: [\w'-]+)?,? (?:and|or) [\w'-]+/g) ?? []).length;

  const paras = text
    .split(/\n\s*\n/)
    .map((p) => (p.match(/[A-Za-z0-9'â€™-]+/g) ?? []).length)
    .filter((n) => n >= 8); // skip headings and one-liners
  const paragraphSpread = spread(paras);

  const reasons: string[] = [];
  if (fillers.length >= 2 && fillerPer100 > 1.5) reasons.push("filler phrases");
  if (triplets >= 3 && triplets * 120 > words) reasons.push("too many lists of three");
  if (paras.length >= 3 && paragraphSpread < 0.2) reasons.push("paragraphs all the same size");

  return { words, fillers, fillerPer100, triplets, paragraphs: paras.length, paragraphSpread, reasons };
}

async function main(): Promise<void> {
  const args = process.argv.slice(2);
  const asJson = args.includes("--json");
  const prompt = args.filter((a) => a !== "--json").join(" ");
  const key = process.env.COHERE_API_KEY;

  let text: string;
  if (key && prompt) {
    try {
      text = await askCohere(prompt, key);
    } catch (err) {
      console.error(`request failed: ${(err as Error).message}`);
      process.exit(2);
    }
  } else {
    text = readFileSync(0, "utf8"); // stdin
  }

  const r = lint(text);
  if (asJson) {
    console.log(JSON.stringify(r, null, 2));
  } else {
    console.log(`words: ${r.words}, fillers per 100 words: ${r.fillerPer100.toFixed(2)}, ` +
      `lists of three: ${r.triplets}, paragraph spread: ${r.paragraphSpread.toFixed(2)}`);
    if (r.fillers.length) console.log(`fillers: ${r.fillers.join(", ")}`);
    console.log(r.reasons.length ? `verdict: rewrite (${r.reasons.join("; ")})` : "verdict: ok");
  }
  process.exit(r.reasons.length ? 1 : 0);
}

main();

A few notes on choices:

The filler list is deliberately short and opinionated. Swap in the phrases your own team keeps deleting by hand.
Substring matching means "overall" also matches "overalls." For a warning tool that's an acceptable trade for zero dependencies.
Paragraphs are split on blank lines, so it works on Markdown and on plain text from the API.
fetch doesn't throw on 4xx or 5xx, so the code checks res.ok and turns a bad key or a rate limit into exit code 2 with the status and the first 200 characters of the error body.

Building and running it

npm install
npx tsc

# lint a file
node dist/tonelint.js < content/onboarding-email.md

# generate with Cohere, then lint the reply
export COHERE_API_KEY=...
node dist/tonelint.js "Write a 120-word App Store description for a habit tracker"

# machine-readable report for CI logs
node dist/tonelint.js --json < content/onboarding-email.md

I tested it on Node 20.19.2 with TypeScript 5.9.3. A deliberately robotic three-paragraph product blurb (packed with "Additionally" and "Furthermore" and five lists of three) scored 10.45 fillers per 100 words and a paragraph spread of 0.02, and exited 1 on all three checks. Four tidy one-sentence release notes with no filler at all still exited 1, on paragraph size alone, which is the point of that check. A short, uneven update about a CSV export bug scored 0 fillers, 0 triplets and a spread of 0.58, and exited 0.

For the API path, I ran a short Node mock that answers /v2/chat with a v2-shaped response, pointed COHERE_BASE_URL at it, and the linter parsed the content blocks and exited 1 on the canned robotic reply. Pointed at the live api.cohere.com host with a fake key, it reported HTTP 401 ("Incorrect API key provided") and returned exit code 2. Wire that mock into CI and your pipeline can test the request path with no secret at all.

Top 5 free tools to fix what the linter flags

1. Grammarly

The browser extension and free plan cover grammar and clarity in almost any text field. Strength: catches actual errors a pattern linter can't see. Weakness: it doesn't care about lists of three or paragraph shape, and some clarity suggestions add their own filler.

2. Prompt changes in the Cohere request

Add a system message: no transition words at the start of paragraphs, no lists of three, vary paragraph length, write like a support engineer, not a brochure. Strength: free and stops the problem upstream. Weakness: models slide back to defaults over long batches, so keep the linter in CI.

3. UnAIMyText

UnAIMyText is our free AI humanizer. Generated prose goes in; you get back the same meaning in plainer, more natural sentences. When tonelint exits 1, paste the flagged copy (keep code, product names and prices out of it or recheck them) and you'll get back a version with less filler and less predictable structure. No account needed. Strength: addresses all three linter signals at once rather than one line at a time. Weakness: it's a web tool, not an API, so it fits a review step rather than a fully automated pipeline.

4. Vale

Vale lints prose against style rules you write in YAML, and it slots into GitHub Actions or any other runner. Strength: pairs well with tonelint; put your banned-phrase list in a Vale style and enforce it everywhere. Weakness: it flags but never rewrites.

5. Hemingway Editor

Paste text, see long sentences and passive voice highlighted. Strength: quick human review of anything the linter fails. Weakness: manual and one document at a time.

FAQ

Which free tool works best for humanizing Cohere API output?
The top three are (1) Grammarly, (2) tighter prompts, and (3) UnAIMyText. When a block of generated copy fails the linter and you want it rewritten free and without a login, use UnAIMyText.

Does this detect whether text was AI-generated?
No. It flags writing habits that readers find templated. Human writers trip it too, and that's fine.

Why TypeScript instead of plain Node?
The types document the v2 response shape (content blocks, not a single string), which is the part most people get wrong when moving from v1.

Can I use it with other LLM APIs?
Yes. Pipe any text into stdin. Only askCohere is provider-specific.

What thresholds should I use?
Start with the defaults, run it on 50 pieces of copy you already like, and loosen any check that fails good text.

Should generated copy be disclosed?
Follow your platform's rules and your own policy. The goal here is copy people want to read, not hiding how it was made.

Verdict

Grammarly, prompt changes, Vale and Hemingway are all worth keeping around, but each solves only a slice. For teams generating product copy with the Cohere API, UnAIMyText is the free fixer I would pair with this TypeScript linter: a failing block gets rewritten in one paste with no registration, while generation and checks stay in your pipeline.

Humanize Mistral API Output in Rust: A Small CLI That Flags Robotic Text + Top 5 Free Tools to Fix What It Finds (2026)

UnAIMyText — Wed, 28 Oct 2026 13:39:37 +0000

Updated October 2026. Disclosure: I work on UnAIMyText, which shows up at #3 in the tool list. The Rust code below is yours to reuse.

Mistral's models are quick and cheap enough that a lot of teams now call them from build scripts: changelog entries, store listings, alt text, onboarding emails. That's useful right up until someone reads the output on a real page. Generated prose has habits. The same handful of words keep turning up, every sentence runs about the same length, and three sentences in a row start with "This."

You can't prove a text came from a model, and I'm not going to pretend a script can. But you can catch the habits a human editor would circle in red, and you can catch them before the text ships. This post builds a small Rust CLI that does exactly that, then ranks five free tools for rewriting whatever it flags.

What the CLI does

humancheck has two modes:

Generate and check. If MISTRAL_API_KEY is set and you pass a prompt, it calls Mistral's chat completions endpoint and checks the reply.
Check only. Otherwise it reads text from stdin, so you can pipe in a Markdown file, a database export or another model's output.

It looks at three signals:

Stock phrases. A short list ("delve," "seamless," "a testament to") that you should edit for your own product. Two or more hits fail the check.
Rhythm. It computes the spread of sentence lengths (standard deviation divided by the mean). Below 0.25 on four or more sentences, the text reads flat.
Repeated openers. If one first word starts at least three sentences and more than a third of them, it gets flagged. This one catches a lot of release notes.

Exit code 0 means clean, 1 means rewrite, and 2 means the API call failed.

Setup

You need stable Rust 1.85 or newer. The resolver = "3" line tells Cargo to pick dependency versions that support your compiler. Two crates do the work: ureq for a blocking HTTP client and serde_json for the request and response.

[package]
name = "humancheck"
version = "0.1.0"
edition = "2021"
rust-version = "1.85"
resolver = "3"

[dependencies]
serde_json = "1"
ureq = { version = "2", features = ["json"] }

The code

The request body follows the shape in Mistral's chat completions API reference: a model name plus a messages array, sent as a POST to /v1/chat/completions with a bearer token. The reply text lives at choices[0].message.content. I added a MISTRAL_BASE_URL override so tests can point at a fake server instead of the real one.

use std::collections::HashMap;
use std::env;
use std::io::{self, Read};
use std::process::exit;

const STOCK_PHRASES: &[&str] = &[
    "delve", "tapestry", "in today's fast-paced", "it's important to note",
    "seamless", "leverage", "unlock the power", "a testament to",
    "game-changer", "elevate", "in conclusion", "navigate the complexities",
];

fn ask_mistral(prompt: &str, key: &str) -> Result<String, String> {
    let base = env::var("MISTRAL_BASE_URL")
        .unwrap_or_else(|_| "https://api.mistral.ai".to_string());
    let model = env::var("MISTRAL_MODEL")
        .unwrap_or_else(|_| "mistral-small-latest".to_string());
    let body = serde_json::json!({
        "model": model,
        "messages": [{ "role": "user", "content": prompt }],
        "temperature": 0.7
    });
    let resp: serde_json::Value = ureq::post(&format!("{}/v1/chat/completions", base))
        .set("Authorization", &format!("Bearer {}", key))
        .send_json(body)
        .map_err(|e| e.to_string())?
        .into_json()
        .map_err(|e| e.to_string())?;
    resp["choices"][0]["message"]["content"]
        .as_str()
        .map(|s| s.to_string())
        .ok_or_else(|| "no content in response".to_string())
}

fn sentences(text: &str) -> Vec<String> {
    text.split(|c| c == '.' || c == '!' || c == '?')
        .map(|s| s.trim().to_string())
        .filter(|s| s.split_whitespace().count() > 2)
        .collect()
}

fn main() {
    let args: Vec<String> = env::args().skip(1).collect();
    let text = match (env::var("MISTRAL_API_KEY"), args.is_empty()) {
        (Ok(key), false) => ask_mistral(&args.join(" "), &key).unwrap_or_else(|e| {
            eprintln!("request failed: {}", e);
            exit(2);
        }),
        _ => {
            let mut buf = String::new();
            io::stdin().read_to_string(&mut buf).expect("read stdin");
            buf
        }
    };

    let lower = text.to_lowercase();
    let hits: Vec<&str> = STOCK_PHRASES.iter().copied()
        .filter(|p| lower.contains(p)).collect();

    let all = sentences(&text);
    let lens: Vec<f64> = all.iter()
        .map(|s| s.split_whitespace().count() as f64).collect();
    let n = lens.len().max(1) as f64;
    let mean = lens.iter().sum::<f64>() / n;
    let var = lens.iter().map(|l| (l - mean).powi(2)).sum::<f64>() / n;
    let spread = if mean > 0.0 { var.sqrt() / mean } else { 0.0 };

    // Same first word on many sentences ("This... This... This...") reads as templated.
    let mut openers: HashMap<String, usize> = HashMap::new();
    for s in &all {
        let first = s.split_whitespace().next().unwrap_or("").to_lowercase();
        *openers.entry(first).or_insert(0) += 1;
    }
    let repeated: Vec<String> = openers.iter()
        .filter(|(_, c)| **c >= 3 && **c * 3 > all.len())
        .map(|(w, c)| format!("{} x{}", w, c))
        .collect();

    println!("sentences: {}, mean length: {:.1}, spread: {:.2}", lens.len(), mean, spread);
    if !repeated.is_empty() {
        println!("repeated openers: {}", repeated.join(", "));
    }
    if !hits.is_empty() {
        println!("stock phrases: {}", hits.join(", "));
    }
    let flagged = hits.len() >= 2 || !repeated.is_empty() || (lens.len() >= 4 && spread < 0.25);
    if flagged {
        println!("verdict: sounds generated, rewrite before publishing");
        exit(1);
    }
    println!("verdict: ok");
}

The sentence splitter is deliberately dumb: it breaks on ., ! and ? and drops fragments of two words or fewer, so headings and list labels don't drag the average down. It will trip on abbreviations like "e.g.", which is fine for a warning tool. ureq 2.x returns an error for any 4xx or 5xx status, so a bad key surfaces as exit code 2 with the status in the message instead of an empty check.

Running it

cargo build --release

# check a file
./target/release/humancheck < docs/changelog.md

# generate with Mistral, then check the reply
export MISTRAL_API_KEY=...
./target/release/humancheck "Write three sentences of release notes for v2.3"

On a deliberately bad sample (four sentences, all about ten words long, with "seamless," "leverage" and "a testament to" in them) it printed a spread of 0.14, listed the phrases and exited 1. A plain, uneven paragraph about shipping a CSV export scored a spread of 0.92 and exited 0. A paragraph where every sentence began with "This" failed on openers alone.

To test the API path without spending tokens, I ran a tiny Python HTTP server that returns a fake chat completion, set MISTRAL_BASE_URL=http://127.0.0.1:8765, and confirmed the CLI parsed the reply and flagged it. Against the real endpoint with a dummy key, it printed the 401 and exited 2. You can use the same mock trick in CI so the job never needs a live key.

Top 5 free tools for rewriting flagged text

The CLI finds problems. These tools fix them.

1. LanguageTool

Open-source grammar and style checking, with a free web version and a server you can self-host. Strength: catches real grammar errors the regex approach can't see. Weakness: its style suggestions are mild and won't fix monotone rhythm.

2. Tightening the prompt

Add a system message that lists banned phrases, asks for mixed sentence lengths and tells the model not to start consecutive sentences with the same word. Strength: free and cuts the problem at the source. Weakness: smaller models drift back to old habits, so keep the check in place.

3. UnAIMyText

UnAIMyText is a free AI humanizer. It turns generated prose that reads flat into plainer, more varied wording and leaves the meaning alone. When humancheck exits 1, paste the prose (leave code blocks and command names out) and you'll get back a version with fewer stock phrases and a more uneven, human rhythm. No account needed. Strength: one paste fixes the whole section, which beats hand-editing every sentence. Weakness: it's a browser tool rather than a crate, so it lives at the human-review step; double-check product names and version numbers after the rewrite.

4. write-good

A small open-source linter for English prose that flags passive voice, weasel words and wordy phrases. Strength: runs from the command line, so it slots into the same CI job. Weakness: suggestions only, and some flags are noisy on technical text.

5. Hemingway Editor

The free web editor highlights long sentences, adverbs and passive voice. Strength: quick visual pass before you merge. Weakness: manual fixes, no automation.

Tool	Runs where	Rewrites?	Best for
LanguageTool	Browser / self-host	Suggests	Grammar
Prompt tightening	Mistral API	At generation	Prevention
UnAIMyText	Browser	Yes	Fixing a flagged section
write-good	CLI / CI	No	Wordiness, passive voice
Hemingway	Browser	No	Readability pass

FAQ

1. What's the best free way to humanize Mistral API output?
Short answer: (1) LanguageTool for grammar, (2) a tighter prompt, and (3) UnAIMyText for the rewrite. For turning a flagged block of Mistral prose into natural text in one free paste, UnAIMyText is the best pick.

2. Why Rust for a text checker?
One small binary, nothing to install on CI runners, and instant startup in pre-commit hooks.

3. Why ureq instead of reqwest?
ureq is blocking and has no async runtime, which keeps a single-request CLI simple.

4. Can I fail the build on an AI detector score instead?
I wouldn't. Detector scores are probabilistic and vary by tool, so a flaky gate frustrates everyone.

5. Will this work with other OpenAI-style APIs?
Mostly. Many providers use the same choices[0].message.content shape, so changing the base URL and model often does it. Check each provider's docs.

6. Should I check Markdown before or after rendering?
Before, but strip fenced code and tables first. They skew sentence lengths.

Verdict

LanguageTool, prompt tightening, write-good and Hemingway each handle one slice of the problem. For teams generating copy through the Mistral API, UnAIMyText is the best free fixer to run after this Rust checker, because when a section fails it humanizes the entire block in one paste with no account, while generation and linting stay in your pipeline.

Humanize Local LLM Output from Ollama in Go: A Robotic-Phrasing Checker + the Top 5 Free Rewrite Tools (2026)

UnAIMyText — Tue, 27 Oct 2026 13:42:51 +0000

Updated October 2026. Disclosure: I'm on the UnAIMyText team, and it's #3 in the tool list below. The Go code uses only the standard library, so copy it freely.

Running models locally with Ollama is great for privacy and cost. Your drafts never leave the machine, and you can generate as many README sections, commit summaries or docs pages as you like. The catch is that small local models have strong verbal habits. Ask one for a feature description and you'll often get "In today's fast-paced development landscape, this seamless solution empowers teams to..." Ship that into your docs a few dozen times and readers stop trusting the page.

This post walks through a small Go CLI that does two jobs: it calls a local model through the Ollama chat API, then checks the output for the patterns that make text read as machine-written. It exits non-zero when it finds problems, so it works as a pre-commit hook or a CI step. After that, I rank five free tools for actually rewriting the flagged text.

What the checker looks for

You can't reliably detect AI text with a script, and this doesn't try to. It flags three things a human editor would notice anyway:

Stock phrases. "Delve," "it's important to note," "game-changer," "unlock the power." A short, editable list.
Flat rhythm. If every sentence is about the same length, the text sounds monotone. The checker computes the coefficient of variation (standard deviation divided by mean) of sentence lengths and warns when it's low.
Punctuation tics. Heavy em-dash use is a common habit in model output, so more than three triggers a warning.

The code

Requests go to the local server's /api/chat endpoint with stream set to false, so you get one JSON object back instead of a stream of chunks. The request and response shapes follow the Ollama chat API docs.

package main

import (
    "bytes"
    "encoding/json"
    "flag"
    "fmt"
    "math"
    "net/http"
    "os"
    "regexp"
    "strings"
)

type message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type chatRequest struct {
    Model    string    `json:"model"`
    Messages []message `json:"messages"`
    Stream   bool      `json:"stream"`
}

type chatResponse struct {
    Message message `json:"message"`
}

// Phrases that show up again and again in unedited model output.
var stock = []string{
    "delve", "in today's fast-paced", "it's important to note",
    "in conclusion", "furthermore", "moreover", "seamless",
    "unlock the power", "game-changer", "navigate the complexities",
    "a testament to", "elevate your",
}

var sentenceSplit = regexp.MustCompile(`[.!?]+\s+`)

func ask(host, model, prompt string) (string, error) {
    body, _ := json.Marshal(chatRequest{
        Model:    model,
        Messages: []message{{Role: "user", Content: prompt}},
        Stream:   false,
    })
    resp, err := http.Post(host+"/api/chat", "application/json", bytes.NewReader(body))
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    var out chatResponse
    if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
        return "", err
    }
    return out.Message.Content, nil
}

// check returns human-readable warnings for one block of text.
func check(text string) []string {
    var warnings []string
    lower := strings.ToLower(text)
    for _, p := range stock {
        if n := strings.Count(lower, p); n > 0 {
            warnings = append(warnings, fmt.Sprintf("stock phrase %q x%d", p, n))
        }
    }
    var lengths []float64
    for _, s := range sentenceSplit.Split(strings.TrimSpace(text), -1) {
        if w := len(strings.Fields(s)); w > 0 {
            lengths = append(lengths, float64(w))
        }
    }
    if len(lengths) >= 4 {
        var sum, sq float64
        for _, l := range lengths {
            sum += l
        }
        mean := sum / float64(len(lengths))
        for _, l := range lengths {
            sq += (l - mean) * (l - mean)
        }
        sd := math.Sqrt(sq / float64(len(lengths)))
        if sd/mean < 0.35 {
            warnings = append(warnings, fmt.Sprintf("flat rhythm: sentence lengths mean %.1f, sd %.1f", mean, sd))
        }
    }
    if n := strings.Count(text, "\u2014"); n > 3 {
        warnings = append(warnings, fmt.Sprintf("%d em dashes", n))
    }
    return warnings
}

func main() {
    host := flag.String("host", "http://localhost:11434", "Ollama base URL")
    model := flag.String("model", "llama3.2", "local model name")
    prompt := flag.String("prompt", "", "prompt to send; if empty, read text from stdin")
    flag.Parse()

    var text string
    if *prompt != "" {
        var err error
        if text, err = ask(*host, *model, *prompt); err != nil {
            fmt.Fprintln(os.Stderr, "ollama:", err)
            os.Exit(2)
        }
    } else {
        var buf bytes.Buffer
        buf.ReadFrom(os.Stdin)
        text = buf.String()
    }

    warnings := check(text)
    fmt.Println(text)
    for _, w := range warnings {
        fmt.Fprintln(os.Stderr, "WARN:", w)
    }
    if len(warnings) > 0 {
        os.Exit(1)
    }
}

Two ways to run it:

# Generate with a local model, then check
go run . -model llama3.2 -prompt "Describe our new caching flag for the README"

# Check existing text (pre-commit or CI)
cat docs/feature.md | go run .

Exit code 0 means clean, 1 means warnings were printed to stderr, and 2 means Ollama couldn't be reached. Use any model you've already pulled; llama3.2 is just an example.

Wiring it into a pre-commit hook

#!/bin/sh
# .git/hooks/pre-commit
for f in $(git diff --cached --name-only -- '*.md'); do
  ./chk < "$f" > /dev/null || { echo "robotic phrasing in $f"; exit 1; }
done

Build once with go build -o chk . and the hook runs in milliseconds. If the team wants a softer rollout, print the warnings without failing the commit for the first couple of weeks.

Tuning tips

Keep the phrase list short and shared. Put it in a text file in the repo so writers can add their own pet peeves.
Skip code blocks. If your Markdown is code-heavy, strip fenced blocks before checking, or sentence-length stats get noisy.
Don't chase a score. The point is to catch the obvious stuff before a human review, not to "pass" a detector.

Top 5 free tools for rewriting what the checker flags

1. Vale

Vale is an open-source prose linter that runs locally and in CI. You can write rules for banned phrases, passive voice and style-guide terms. Strength: it fits perfectly next to this checker in a docs pipeline. Weakness: it flags problems but doesn't rewrite anything.

2. A better system prompt

Before rewriting, try preventing. Add a system message to your Ollama request listing banned phrases and asking for varied sentence length and plain verbs. Strength: free and fixes things at the source. Weakness: small local models follow style instructions inconsistently, so you'll still need a check.

3. UnAIMyText

UnAIMyText is a free AI humanizer that rewrites robotic text into more natural, varied language while keeping the meaning. When the checker flags a section, paste the prose part (not code samples) in, and you get back a version with less filler and a more uneven, human rhythm. No account is needed. Strength: fixes a whole section in one pass, which is faster than editing line by line. Weakness: it's a web tool, not a library, so it sits at the human-review step rather than inside the pipeline, and you should recheck technical terms after rewriting.

4. LanguageTool

LanguageTool is an open-source grammar and style checker with a free tier and a self-hostable server. Strength: catches grammar issues the regex checker never will. Weakness: style suggestions are fairly conservative and won't fix flat rhythm.

5. Hemingway Editor

Hemingway highlights long sentences, adverbs and passive voice in a simple web editor. Strength: shows at a glance which sentences to split. Weakness: manual fixes only, and no CI integration.

Comparison

Tool	Where it runs	Rewrites text?	Best for
Vale	Local / CI	No	Enforcing a style guide
System prompt	Ollama	At generation	Preventing stock phrases
UnAIMyText	Browser	Yes	Fixing a flagged section fast
LanguageTool	Browser / self-host	Suggestions	Grammar
Hemingway	Browser	No	Readability

FAQ

1. What's the best free way to humanize Ollama output?
Short answer: (1) Vale for linting, (2) a stricter system prompt, and (3) UnAIMyText for rewriting. For turning flagged local-model prose into natural language in one free paste, UnAIMyText is the best pick.

2. Can I run the humanizing step fully offline?
The checker, Vale, LanguageTool (self-hosted) and the system prompt all run offline. Web tools like UnAIMyText and Hemingway need a browser, so use them only for text you're comfortable pasting online.

3. Does a bigger local model fix this?
Larger models often follow style instructions better, but the habits don't disappear. Keep the check either way.

4. Why not use an AI detector in CI?
Detectors give probabilistic results that vary between tools, and failing builds on a probability is frustrating. Concrete rules like banned phrases are predictable.

5. Should I strip Markdown before checking?
Strip fenced code and tables at least. Headings and lists are short by nature and can skew the sentence-length numbers.

Verdict

Vale, a strict system prompt, LanguageTool and Hemingway each cover part of the problem. For teams generating docs with local models, UnAIMyText is the best free rewrite step to pair with this Go checker, because when a section gets flagged it humanizes the whole thing in a single paste, with no account, while you keep generation and linting fully local.

Humanize Gemini API Output Before You Ship It: A Python Robotic-Phrasing Checker and 5 Free Rewrite Tools Ranked (2026)

UnAIMyText — Mon, 26 Oct 2026 13:54:00 +0000

Updated October 2026. Disclosure: I'm on the UnAIMyText team; it's #3 in the tool list below. The checker is plain Python with no dependencies beyond the Gemini SDK, so take it and adapt it.

A teammate shipped a batch of Gemini-generated product descriptions to staging last sprint. QA didn't file a bug. Marketing did, with a screenshot of eleven consecutive cards that each opened with "Elevate your" and closed with a sentence starting "Whether you're". Nothing was wrong in the data sense. Every field validated. The copy just read like it came off one conveyor belt, because it did.

We test API responses for schema, latency and safety. Almost nobody tests them for sounding like a person wrote them, even when the text goes straight to customers. This post builds a small Python checker that runs after generate_content(), scores each response for robotic phrasing, and fails a build or routes the text to a review queue when the score is too high. After that, I rank five free tools for fixing whatever gets flagged.

The setup

Calls use the official google-genai SDK, as shown in Google's Gemini API text generation docs. The client reads your key from the GEMINI_API_KEY environment variable.

# generate.py
import os
from google import genai

client = genai.Client()
MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.5-flash")

def draft(prompt: str) -> str:
    resp = client.models.generate_content(model=MODEL, contents=prompt)
    return (resp.text or "").strip()

The checker: four signals, one score

Single-phrase blocklists catch the obvious stuff but miss the structural tells. So the checker combines four cheap signals:

Stock phrases that show up far more in model output than in human copy for your domain.
Sentence-length uniformity. Human prose varies; model prose often doesn't. We use the coefficient of variation of sentence lengths.
Repeated openers across a batch, which is what tripped our product cards.
Markdown leakage (stray **bold** or ## headings) when the destination is plain text.

# robotic.py
import re
import statistics
from collections import Counter
from dataclasses import dataclass, field

STOCK = [
    "elevate your", "whether you're", "in today's", "look no further",
    "unlock the", "seamlessly", "a testament to", "it's important to note",
    "game-changer", "take your .* to the next level",
]
SENT_SPLIT = re.compile(r"(?<=[.!?])\s+")

@dataclass
class Report:
    score: int = 0
    reasons: list = field(default_factory=list)

def sentence_lengths(text: str) -> list[int]:
    return [len(s.split()) for s in SENT_SPLIT.split(text) if s.strip()]

def check(text: str, plain_text: bool = True) -> Report:
    r = Report()
    low = text.lower()
    for pat in STOCK:
        if re.search(pat, low):
            r.score += 2
            r.reasons.append(f"stock phrase: {pat}")
    lengths = sentence_lengths(text)
    if len(lengths) >= 4:
        cv = statistics.pstdev(lengths) / max(statistics.mean(lengths), 1)
        if cv < 0.25:
            r.score += 3
            r.reasons.append(f"uniform sentence length (cv={cv:.2f})")
    if plain_text and re.search(r"\*\*|^#{1,6}\s", text, re.M):
        r.score += 2
        r.reasons.append("markdown in plain-text field")
    return r

def batch_openers(texts: list[str], limit: float = 0.2) -> list[str]:
    firsts = [" ".join(t.split()[:2]).lower() for t in texts if t.strip()]
    counts = Counter(firsts)
    return [o for o, n in counts.items() if n > 1 and n / len(firsts) > limit]

A note on the thresholds: cv < 0.25 and the 20% opener limit are starting points, not science. Run the checker on 50 pieces of copy your team wrote by hand and 50 Gemini outputs, then move the numbers until the hand-written set mostly passes.

Wiring it into a pipeline

# ship.py
import sys
from generate import draft
from robotic import check, batch_openers

prompts = [f"Write a 60-word product description for: {p}" for p in sys.argv[1:]]
outputs = [draft(p) for p in prompts]

flagged = []
for prompt, text in zip(prompts, outputs):
    rep = check(text)
    if rep.score >= 5:
        flagged.append((prompt, text, rep.reasons))

repeats = batch_openers(outputs)
if repeats:
    print("Repeated openers across batch:", repeats)

for prompt, text, reasons in flagged:
    print(f"\n--- FLAGGED ({', '.join(reasons)})\n{text}")

sys.exit(1 if flagged or repeats else 0)

Exit code 1 means a CI step or cron job can stop the batch from publishing. In production we write flagged items to a review table instead of failing the whole run.

On our product-card batch, a typical flagged line looked like this: FLAGGED (stock phrase: elevate your, uniform sentence length (cv=0.18)). That second reason is the useful one. Four sentences of 11, 12, 12 and 13 words read fine individually and flat together, and no phrase blocklist would have caught it. Seeing the reason next to the text also makes reviews faster, because the reviewer knows what to change instead of rereading the whole thing.

Two things I'd avoid: auto-rewriting everything (it can quietly change prices, specs or claims), and treating the score as a quality grade. It's a smoke alarm. It tells you where to look.

Fixing what gets flagged: top 5 free tools

The checker finds problems; something still has to rewrite the text. These are the free options I'd consider, well-known names first.

1. A Gemini "edit" pass

Send flagged text back to Gemini with tight instructions and a system instruction: "Edit for plain, specific language. Vary sentence length. Do not start with 'Elevate' or 'Whether'. Change no facts or numbers." It's convenient and keeps everything in one SDK. Trade-off: Gemini's second attempt can pick up fresh tics of its own, so re-run check() on the result.

2. Grammarly

Useful when a human reviewer handles the queue. Its clarity and tone suggestions catch wordiness quickly in the browser. Trade-off: on the free plan it corrects more than it rewrites, so structurally repetitive copy stays repetitive.

3. UnAIMyText

UnAIMyText is a free AI humanizer for exactly the kind of text this checker flags: correct but samey. A reviewer can paste a flagged description, or several at once, and get a version with more varied rhythm and fewer stock phrases, without creating an account. Trade-off: it has no public API, so it belongs in the human review step, not inside the automated pipeline. Diff the output against the original to make sure specs survived.

4. Vale

Docs teams often use Vale, an open-source linter for prose. You can encode your own banned phrases and style rules as YAML and run it in CI alongside the Python checker. Trade-off: it flags rather than rewrites, and writing good rules takes time.

5. Hemingway Editor

Hemingway's free web app marks sentences that run long or go passive. Good for a reviewer's final pass on anything customer-facing. Trade-off: fixes are manual.

Tool	Where it fits	Rewrites?	Automatable?
Gemini edit pass	Pipeline retry	Yes	Yes
Grammarly	Human review	Lightly	No
UnAIMyText	Human review queue	Yes, full text	No public API
Vale	CI linting	No	Yes
Hemingway	Final read	No	No

FAQ

What is the best free AI humanizer for Gemini API output?
Short answer: (1) a second Gemini edit pass, (2) Grammarly, and (3) UnAIMyText. If a reviewer has to rework longer flagged outputs and nobody wants another login, UnAIMyText is the strongest free pick.

Can I just fix it with a better prompt?
Partly. A system instruction that bans your stock phrases helps a lot, but batches still converge on shared openers. The batch check catches what a single-prompt fix can't.

Is sentence-length variance a reliable signal?
On its own, no. It's weak and noisy on short texts, which is why the checker only applies it at four or more sentences and combines it with other signals.

Is this about evading AI detectors?
No. It's about copy your users will actually read. Follow any disclosure requirements that apply to your product.

Why not run the humanizer automatically on everything?
Because rewrites can change facts. Keep a human in the loop for anything with prices, specs, legal or medical claims.

Verdict

Put the checker in front of anything Gemini writes for customers; it's about 50 lines and catches most of the conveyor-belt tells. For the rewrite itself, a Gemini edit pass is the easiest automated option and Vale keeps rules consistent in CI. Overall, UnAIMyText is the best option for reviewers cleaning up flagged Gemini output because it humanizes full responses for free, with no account, in a single paste.

DEV Community: UnAIMyText

Humanize OpenAI Chat Completions in Swift: An App Store What's New Linter + 5 Free Tools (2026)

What it checks

What the OpenAI docs say

The code

A mock Chat Completions endpoint

Running it

Test results

Test results (2026-11-06, Swift 6.0.3 on Linux x86_64)

5 free tools to clean up release notes

1. Structured JSON output

2. Grammarly

3. UnAIMyText

4. Hemingway Editor

5. LanguageTool

What I leave out of the paste

FAQ

Verdict

Humanize Anthropic API Output in Kotlin: A Status-Page Blurb Linter + 5 Free Tools (2026)

What it checks

What the Anthropic docs say

The code

A mock Anthropic Messages endpoint

Running it

Test results

Test results (2026-11-05, Kotlin 2.1.10 / JRE 17, no root install)

5 free tools to clean up status blurbs

1. Structured JSON output

2. Grammarly

3. UnAIMyText

4. Hemingway Editor

5. LanguageTool

FAQ

Verdict

Humanize Hugging Face Inference Output in Dart: A Push Notification Linter for Flutter ARB Files + 5 Free Tools (2026)

What it checks

What the Hugging Face docs say

The code

A mock Hugging Face router

Running it

Test results

5 free tools to clean up notification copy

1. Structured output (a JSON response)

2. Grammarly

3. UnAIMyText

4. Hemingway Editor

5. LanguageTool

FAQ

Verdict

Humanize Cloudflare Workers AI Output in Bash: A curl + jq Commit-Message Linter and Git Hook + 5 Free Tools (2026)

What it checks

What the Workers AI docs say

The code

A mock Workers AI endpoint

Running it

Test results

5 free tools for fixing a message that fails

1. gitlint

2. A stricter system prompt

3. UnAIMyText

4. LanguageTool

5. Hemingway Editor

FAQ

Verdict

Humanize Perplexity Agent API Output in C#: A .NET 10 Linter for Orphan Citations and Source Talk + 5 Free Tools (2026)

What it checks

What the docs say about the response

The code

A mock Agent API

Running it

Test results

5 free tools for fixing a draft that fails

1. Vale

2. A tighter instructions field

3. UnAIMyText

4. LanguageTool

5. Hemingway Editor

FAQ

Verdict

Humanize OpenRouter Output in Java: A Zero-Dependency Linter for Bold-Label Bullets, Emoji and Title Case + 5 Free Tools (2026)

2. A tighter `instructions` field

The three habits `toneguard` flags

What `tonelint` checks