How to Build a Hermes Agent AI Writing Checker Skill

US keyword research from DataForSEO puts "ai writing checker" near 8,100 monthly searches, with keyword difficulty around 74 and CPC near USD 3.31. That demand is real. The search results are not. Almost every top listing is a hosted detector landing page. None of them teach you how to package detection, style review, and a fixed report format as a portable skill your agent can re-run on every draft.

That gap is the point of this article. An AI writing checker skill packages detection and review steps so Hermes can re-run the same authenticity and quality procedure on drafts without re-prompting from scratch. Hosted detectors still have a place when you need a black-box score from GPTZero, QuillBot, Grammarly, or ZeroGPT. A skill is for teams that want the procedure itself under version control, shared across CLI and messaging gateways, and cheap enough to load only when a draft actually needs review.

Nous Research Hermes Agent is open source under the MIT license and stores skills as on-demand knowledge documents compatible with the agentskills.io standard. Skills live under ~/.hermes/skills/ and load through progressive disclosure: a compact name-and-description index first, full SKILL.md only when the agent decides it needs the procedure. Official Hermes docs put that list layer near roughly 3,000 tokens for the whole catalog, which is why packaging a writing checker as a skill beats pasting a long multi-page prompt into every session.

If you only need a one-off score on a single paragraph, paste it into a detector and move on. If you review blog drafts, help docs, client proposals, or agent-written copy every week, the cost of re-explaining "check for AI patterns, brand voice, and factual claims" adds up. The skill becomes procedural memory for that checklist.

Before writing files, decide the skill's job in one sentence. For most editorial teams, that sentence is: read a draft, apply a fixed authenticity and quality procedure, and write a structured report the human editor can act on.

That is different from a pure AI writing detector. Detectors answer "how machine-like is this text?" A writing checker skill answers that plus "is this draft ready to publish under our rules?" Keep both layers, but never treat a detector score as a pass/fail gate by itself. Independent academic work has already shown high false-positive rates on human text with simple structure, and hybrid drafts (AI draft plus human edit) break most tools. Your skill should collect signals, not issue verdicts that replace editorial judgment.

Inputs the skill accepts

Design for three input shapes so the agent does not invent a new path each time:

• A file path or workspace path to a draft
• Pasted markdown or plain text in chat
• A URL or shared link when the draft lives outside the local machine

Local disk works for solo use. S3 or Google Drive work when you only need object storage. For agentic teams that review concurrent drafts, store source files and finished reports in a shared Fast.io workspace so humans and agents see the same versions, permissions, and audit trail.

Outputs the skill must produce

A useful AI content checker report is boring on purpose. Require the same sections every run:

1. Scope: file name, word count, date, model used for the review
2. Authenticity signals: AI-likeness notes (repetitive transitions, uniform sentence rhythm, empty abstractions, missing specifics)
3. Quality findings: clarity issues, unsupported claims, weak openings, keyword stuffing, brand-voice drift
4. Severity: blocker, major, minor for each finding
5. Rewrite targets: exact spans or headings to fix, not vague "make it better"
6. Residual risk: what the skill could not verify (citations, product claims, legal language)

Save the report next to the draft under a predictable name such as reviews/YYYY-MM-DD-slug-writing-check.md. Consistency is what makes later automation and Metadata Views useful.

Hermes skills are markdown with YAML frontmatter. Official creating-skills docs recommend a skill when the capability is instructions plus existing tools (terminal, file read, web extract), not a new Python integration inside the agent core. An AI writing checker fits that definition cleanly.

Create the directory, then write SKILL.md:

mkdir -p ~/.hermes/skills/writing/ai-writing-checker

---
name: ai-writing-checker
description: Review drafts for AI-likeness signals and publish quality. Use when checking AI writing, detecting machine tone, or running a content quality pass before publish.
version: 1.0.0
license: MIT
metadata:
  hermes:
    tags: [writing, editorial, quality, detection]
    category: writing
---

### AI Writing Checker

### When to Use
Load this skill when the user asks to:
- Run an AI writing checker or AI content checker on a draft
- Detect AI writing patterns before publish
- Produce a structured editorial quality report
- Re-check a revised draft against the same criteria

Do not load for pure grammar fixes unless the user also wants authenticity and publish readiness.

### Procedure
1. Identify the draft source (path, paste, or URL) and confirm word count.
2. Run authenticity heuristics first (see references/authenticity-checklist.md if needed).
3. Run quality review second: structure, claims, voice, SEO title/description length when present.
4. Write the report using templates/report.md.
5. Save the report next to the draft and summarize blockers in chat.

### Pitfalls
- Detector scores alone are not publish decisions.
- Short samples under roughly 300 words are noisy; state low confidence.
- Hybrid human-AI drafts often fool pure detectors; focus on fixable findings.

### Verification
Confirm the report file exists, includes all six required sections, and lists at least one residual risk or an explicit "none found".

That skeleton follows the official section order: When to Use, Procedure, Pitfalls, Verification. Progressive disclosure depends on a tight description field. Official guidance keeps descriptions short and keyword-rich so skills_list() can match natural requests like "run an AI writing detector on this draft" without loading every skill body.

Supporting files

Put edge-case detail in references/ so the main skill stays short:

~/.hermes/skills/writing/ai-writing-checker/
├── SKILL.md
├── references/
│   ├── authenticity-checklist.md
│   └── quality-rubric.md
├── templates/
│   └── report.md
└── scripts/
    └── wordcount.py

Hermes loads SKILL.md first. The agent only pulls a reference file when the procedure says to, via skill_view with a path. Official progressive disclosure is three levels: list all skills, view one skill, then view a specific support file. That is how you keep token use low until a draft needs the full rubric.

Keep Hermes writing checks and drafts in one workspace

Store drafts, checker skills, and review reports where agents and editors share permissions, version history, and MCP access. Start a 14-day free trial (credit card required) on Solo, Business, or Growth.

Start 14-Day Trial

The procedure body is where most writing-checker skills fail. Authors either paste a detector API call with no editorial judgment, or they write a vague "make the prose better" instruction the model reinterprets every time. Split the work into two passes with hard stop rules.

Pass 1: authenticity signals

Instruct the agent to flag patterns, not assign a fake percentage unless a real detector API returned one:

• Uniform sentence length across long sections
• Empty transitions ("Furthermore", "Moreover", "In conclusion") without new information
• Abstract nouns stacked without examples ("solution", "ecosystem", "journey")
• Perfect parallel lists that say little
• Missing first-person experience, dates, product constraints, or failure modes
• Claims that sound specific but have no source, number, or named tool

If you integrate a third-party AI writing detector API, keep it optional. Declare keys with required_environment_variables in frontmatter so Hermes prompts for secrets only when the skill loads in the local CLI. Official docs stress that missing env vars do not hide the skill from discovery, and messaging sessions tell the user to configure secrets locally instead of collecting keys in chat.

Pass 2: publish quality

After authenticity notes, run the quality checklist your team actually enforces:

• Opening sentence states a concrete claim or problem
• Headings describe section content without keyword stuffing
• Product claims match the source of truth the team trusts
• SEO title stays inside length limits when the draft includes frontmatter
• FAQ answers do not copy section paragraphs word for word
• Links resolve to real destinations

For Fast.io product content, that source of truth is the features reference the team maintains. The skill should refuse to invent capabilities and should mark unverified product claims as blockers.

Report template

Keep templates/report.md copy-pasteable:

### Writing check: {{title}}

- Date:
- Source:
- Word count:
- Reviewer model:

### Authenticity signals
-

### Quality findings
- Severity / Location / Issue / Fix

### Rewrite targets
1.

### Residual risk
-

Tell the agent to fill every section. Empty sections must say "None" so editors know the pass ran.

You do not have to hand-author every line. Official Hermes skills docs describe /learn as the fast path from sources to a reusable skill. Point it at detector API docs, your internal style guide, or the conversation where you just refined a checklist, and the agent authors a skill that follows house standards, then saves it with skill_manage.

Examples that map well to an AI writing checker:

/learn https://docs.example-detector.com/api/v1/scan focus on auth headers, request body, and score fields

/learn the writing review we just did on the pricing page draft; save as ai-writing-checker

/learn filing an editorial pass: authenticity heuristics first, quality second, report next to the draft

/learn works in the CLI, messaging gateway, TUI, and dashboard. There is no separate ingestion engine; the live agent uses tools it already has (read_file, web_extract, and friends), then writes the skill. The write-approval gate still applies if you set skills.write_approval: true in config. That gate stages creates and patches under ~/.hermes/pending/skills/ until a human runs /skills approve.

Update without rewriting the whole skill

Prefer skill_manage with patch when the checklist changes. Official docs call patch the token-efficient update path: only the changed text appears in the tool call. Use full edit only for structural rewrites. After a false positive or a missed brand rule, tell Hermes to patch the Pitfalls section with the concrete case. Skills that never absorb corrections become liabilities.

Install and share across machines

For solo use, a directory under ~/.hermes/skills/ is enough. For teams:

• Publish to a private GitHub skills tap and install with hermes skills install owner/repo/skills/ai-writing-checker
• Host SKILL.md at an HTTPS URL and install with hermes skills install https://example.com/ai-writing-checker/SKILL.md
• Add a shared folder via skills.external_dirs in config.yaml so several machines scan the same catalog

Hub installs run a security scanner for exfiltration patterns, prompt injection, and destructive commands. Community sources can require --force for non-dangerous findings; dangerous verdicts stay blocked. Official optional skills from the Hermes repo install with built-in trust.

Test the skill the way production will call it

Official creating-skills guidance recommends a direct chat test:

hermes chat --toolsets skills -q "Use the ai-writing-checker skill on ~/drafts/sample-post.md"

Or inside a session:

/ai-writing-checker review drafts/sample-post.md and save the report

Confirm the report shape, not just a chat summary. If Hermes improvises sections, tighten the Procedure and template until the output is stable across two or three sample drafts.

A skill solves procedure reuse. It does not solve "where do the drafts and reports live when three editors and two agents touch the same campaign?" Local folders break as soon as someone reviews from another machine. Raw object storage holds files but gives agents little structure. Consumer drives work for people and frustrate agents that need API or MCP access.

Fast.io sits in that gap as the intelligent workspace layer around Hermes Agent. Keep Hermes running on your host (local, Docker, SSH, or another supported backend). Put drafts, style guides, and writing-check reports in an org-owned workspace with granular permissions. Enable Intelligence Mode so the agent can search prior reviews by meaning, not only by filename. Per-file version history keeps concurrent edits auditable when one agent rewrites while an editor comments.

Connect Hermes through the Fast.io MCP server over Streamable HTTP at /mcp (legacy SSE at /sse). Agents use the consolidated MCP toolset for workspace reads and writes; humans use the UI on the same files. When an agent stages the skill bundle and sample reports for a client, ownership transfer hands the workspace to a human admin while the agent can keep access to continue scheduled checks.

For batch review queues, create a Metadata View over report markdown. Ask for fields such as draft title, blocker count, authenticity risk (text), and review date. Editors filter "blockers greater than zero" without opening every report. Pair that with workflow approvals when a human must sign off before publish.

Pricing is org-based: Solo at $29/mo, Business at $99/mo, Growth at $299/mo, each with a 14-day free trial that requires a credit card. Agents can create accounts, but real workspace work runs under a paid organization trial or subscription.

Practical layout

A layout that scales without ceremony:

/campaigns/q3-blog/
  drafts/
  style-guides/
  reviews/
  skills/
    ai-writing-checker/
      SKILL.md
      references/
      templates/

Symlink or copy the skill into ~/.hermes/skills/writing/ on each Hermes host, or point external_dirs at a checked-out skills repo. Keep the canonical skill in the workspace so editorial changes land in one place, then ship them to hosts the same way you ship code.