Building an AI Blog Editor with Claude Skills

I spend an embarrassing amount of time editing. Not writing — editing. Killing em dashes, nuking “It’s worth noting that,” deleting every sentence that ends with “showcasing how X contributes to Y.” My own writing, client writing, guest posts before they go live. Hours.

So I built a tool that does most of it for me. A browser-based AI blog editor powered by Claude Skills — specifically the humanizer skill I run on my own Claude instance — that catches AI writing patterns before they hit publish. This post is the full walkthrough: what I built, why, how it works, and where it falls down.

What is an AI blog editor with Claude Skills?

An AI blog editor with Claude Skills is a reusable set of editorial instructions that turns Claude into a more consistent content assistant. It does not replace a human editor. It replaces the exhausting part where you repeatedly explain your standards every single time you open a new chat.

Think of it as a persistent editorial layer.

A normal prompt says:

“Write a blog post in my tone, make it SEO-friendly, use a good structure, avoid fluff, include FAQs, and make it sound human.”

A Skill says:

“Here is exactly how our blog defines quality. Here are examples. Here is the structure. Here are banned phrases. Here is the SEO checklist. Here is how to format for WordPress. Here is how to decide whether a claim needs a source. Follow this when editing blog content.”

That difference matters.

A prompt is a request.
A Skill is a reusable operating procedure.

Anthropic’s own guidance recommends keeping custom Skills focused, writing clear descriptions so Claude knows when to use them, testing them with multiple prompts, and creating separate Skills for different purposes instead of one giant do-everything Skill.

The problem with AI-assisted content at scale

When you’re running multiple publications — a B2B automation newsletter, an iGaming trade site, a WordPress blog — you’re either writing everything yourself (not sustainable), hiring writers (expensive, slow), or using AI to produce first drafts (fast, but the output has tells).

The tells are consistent. Not always the same words, but the same patterns. Significance inflation: “marking a pivotal moment in the evolution of…” Fake depth via -ing phrases: “underscoring the importance of X, reflecting the broader trend toward Y.” The copula swaps: “this serves as,” “this stands as,” “this functions as” — when the correct word is just “is.” The triple-item lists. The hedge stacks. The signposting (“Let’s dive into…”).

Google’s helpful content classifiers may or may not catch these. Human readers definitely do — they just don’t always know why something feels off. It reads as thin. Puffed up. Produced.

If you’re publishing at volume, cleaning this up manually per post is a real time tax. The alternative — not cleaning it up — compounds over time into a brand voice problem.

What Claude Skills actually are

Before getting into the build, a quick note on what “Claude Skills” means in this context, because the term is used loosely.

In my setup, a Skill is a Markdown file that lives in a specific directory on my Claude instance (/mnt/skills/user/). Each one has a YAML front matter block with metadata — name, version, description, compatibility — and then the actual instruction content. Claude reads the relevant SKILL.md before taking action on a task, which means the behavior is modular and swappable. Different skills for different task types: SEO audits, schema generation, competitor page templates, image gen, content humanization.

The humanizer skill is the one relevant here. It’s based on Wikipedia’s “Signs of AI Writing” page, maintained by WikiProject AI Cleanup, and covers about 29 documented AI writing patterns — everything from promotional language and undue significance framing to the more subtle stuff like negative parallelisms (“It’s not just X, it’s Y”) and fragmented headers.

The skill instructs Claude to:

1. Scan for those specific patterns
2. Rewrite problem sections
3. Do a self-audit pass (“What makes this obviously AI-generated?”)
4. Revise based on that audit
5. Output the final cleaned version

What I wanted was to expose that workflow as a standalone web tool — something I could paste a draft into, hit a button, and get back a cleaned version with annotations showing what got changed and why.

Architecture: one HTML file, one API call

I kept this deliberately simple. The editor is a single HTML file with vanilla JS — no framework, no build step, no npm. It runs entirely in the browser, makes a direct call to the Anthropic /v1/messages endpoint, and renders the output inline.

Here’s the basic structure:

index.html
├── Split-pane editor layout (input left, output right)
├── Textarea for draft input
├── Analyze button
├── Output panel (renders annotated diff or cleaned text)
└── Embedded JS
    ├── API call handler
    ├── System prompt constructor
    └── Response parser

The system prompt is where the actual skill logic lives. I took the core detection patterns from the humanizer SKILL.md — the 29 categories with before/after examples — and condensed them into a structured prompt that tells Claude exactly what to look for, how to annotate changes, and what format to return the output in.

The response format matters a lot. I needed structured output I could actually render in the UI — not just raw text. So the prompt specifies JSON with three fields: cleaned_text, issues_found (array of pattern names hit), and change_log (array of {pattern, original, revised} objects). I strip any markdown fences from the response before parsing.

The system prompt

This is the part that took the most iteration. The first few versions were too generic — Claude would clean the writing but not annotate what it changed. The annotations are the useful part for anyone trying to learn what their AI writing patterns actually are.

The final prompt does a few specific things:

1. Anchors on the pattern list explicitly. Rather than a vague “make this sound human,” the prompt lists the 29 patterns by name with a one-line definition. “Superficial -ing analyses: present participle phrases tacked on to add fake depth (‘showcasing how X contributes to Y’). Remove or restructure.”

2. Requires a self-audit. After producing the initial rewrite, the prompt instructs Claude to ask itself “What still makes this obviously AI-generated?” and revise based on that answer. This two-pass approach noticeably improves output quality over single-pass rewrites.

3. Enforces voice calibration. The prompt includes a section instructing Claude to match sentence rhythm, word choice level, and punctuation habits from the input — so it’s cleaning the writing without replacing it with a different voice. This matters more than people think. A humanizer that strips your em dashes but gives you back corporate passive voice has just traded one problem for another.

4. Specifies the JSON schema. Output must be valid JSON matching a defined structure. No preamble, no backticks, no “Here’s the cleaned version:”. Just the JSON object. This makes parsing trivial and prevents the response from being unparseable when Claude adds explanatory text.

The UI

Nothing fancy, intentionally. Left pane: textarea with monospace font, where you paste the draft. Right pane: two tabs — “Cleaned Text” and “Change Log.”

The cleaned text tab renders the output as formatted HTML. The change log tab renders a table: pattern name, original phrase, revised phrase. Color-coded by pattern category — red for significance inflation (the worst offenders), orange for promotional language, yellow for the subtler stuff.

Below the editor, a “Pattern Hit Summary” shows which of the 29 categories fired and how many times. This is the part I find most useful day-to-day. If “Superficial -ing analyses” shows 6 hits on a 1200-word post, that writer has a habit I can address in the brief, not just in post-production.

I added a word count before/after display because cleaning often reduces length by 8-15%. Good. Shorter is usually better. But it’s useful to see the delta explicitly.

What it catches well

The tool reliably flags:

The copula replacements. “Serves as,” “stands as,” “functions as” where “is” belongs. These are everywhere in AI content and the tool catches them almost perfectly.

Significance inflation. Any sentence that contains “testament to,” “pivotal moment,” “evolving landscape,” “transformative potential,” or “reflects a broader trend” gets flagged. Good. These phrases contribute zero information and signal that the model was padding.

The -ing phrase stacks. The ones at the end of sentences that just restate what was already said: “…contributing to better outcomes, highlighting the importance of X, underscoring the need for Y.” Claude catches these and usually restructures to something direct.

Rule of three and synonym cycling. “The system is powerful, efficient, and scalable.” “It serves as a catalyst, a partner, and a foundation.” The tool breaks these up or removes the redundant terms.

Signposting and preamble. “Let’s dive in,” “Without further ado,” “Here’s what you need to know.” All gone. Good.

Where it falls down?

No tool is clean at the edges. A few honest failure modes:

It sometimes over-corrects voice. When the input is heavily stylized — lots of intentional sentence fragments, casual register — the rewrite can drift toward slightly more formal phrasing than the original. Not a dealbreaker, but it means reviewing the output rather than accepting it wholesale.

It misses context-specific jargon. “Pivotal” in the phrase “pivotal in the iGaming operator ecosystem” is arguably meaningful rather than puffery. The tool flags it anyway. Pattern matching doesn’t know your vertical.

The self-audit pass sometimes introduces new problems. Occasionally Claude fixes the significance inflation in pass one and then in the self-audit adds a slightly different kind of hedging. This is rare but worth checking.

JSON reliability. The API returns valid JSON about 97% of the time. The remaining 3% — usually on very long inputs — it appends a summary sentence after the closing brace. I handle this with a try/catch that falls back to extracting just the cleaned text as plain output if JSON parse fails. Not ideal but workable.

---

Extending it

A few things I’m planning or have partially built:

Tone presets. A selector that adjusts the system prompt for different registers — “trade publication,” “thought leadership,” “SaaS blog,” “personal essay.” The base patterns are the same, but the voice calibration guidance differs.

WordPress integration. A version that pulls draft posts from the WP REST API, runs them through the editor, and pushes the cleaned version back as a new revision. This would slot into my existing content workflow without requiring copy-paste.

Batch mode. Right now it’s one post at a time. Batch mode would accept a list of URLs or post IDs, process them asynchronously, and return a report — useful for auditing an existing archive for AI pattern density.

Pattern heatmap per writer. If you’re managing ghost authors or a writing team, tracking which patterns appear most frequently per contributor is useful data for training and briefing. A simple aggregation layer on top of the change logs would do it.

---

Why normal AI blogging workflows fail

The biggest problem with AI blog content is not grammar. Claude, ChatGPT, Gemini, and similar tools can all produce clean sentences.

The problem is editorial judgment.

AI can write a confident paragraph about almost anything. That does not mean the paragraph deserves to exist.

Most AI-generated blog posts fail for five reasons:

1. They summarize the existing internet instead of adding anything new.
2. They use generic structure: intro, benefits, steps, conclusion, yawn.
3. They lack first-hand experience, screenshots, tests, examples, and friction.
4. They make claims without knowing which ones need verification.
5. They sound polished but empty.

This is why a blog editor Skill is more valuable than a blog writer Skill.

Writing more content is easy. Publishing content worth ranking is the hard part.

Here’s the kicker:

Your AI blog editor should be trained to reject content, not just improve it.

That is where most AI workflows go soft. They treat every draft as something to beautify. A real editor asks nastier questions:

• Is this actually useful?
• Has this already been said 500 times?
• What is the original angle?
• Where is the evidence?
• What screenshot would prove this?
• What section should be deleted?
• Would a reader bookmark this, or just politely forget it?

Claude Skills let you encode those questions into the workflow.

The Editorial Skill Stack framework

I’d build this using what I call the Editorial Skill Stack.

The Editorial Skill Stack is a modular set of Claude Skills that mirrors a real publishing workflow. Each Skill handles one editorial responsibility, and Claude can combine them when the task requires it.

The stack looks like this:

Skill	Purpose	Main output
Content Strategist Skill	Turns a topic into an angle, search intent, outline, and information gain plan	SEO brief
Human Editor Skill	Removes fluff, improves logic, sharpens tone, adds opinion	Edited draft
Fact-Check Skill	Flags claims that need verification and adds source requirements	Claim review
Visual Authority Skill	Suggests screenshots, diagrams, tables, and original media	Media plan
WordPress Publisher Skill	Formats the final article for Gutenberg, metadata, schema, and internal links	Publish-ready post

This is cleaner than stuffing every rule into one prompt.

Why?

Because editorial work is not one task. It is a chain of decisions.

A strategist should think about the angle.
An editor should think about clarity.
A fact-checker should think about risk.
A publisher should think about formatting.

When you separate those jobs, the AI behaves less like a content blender and more like a junior editor with a checklist.

Still not magic. But less chaos. That counts.

What Claude Skills actually contain

A Claude Skill usually begins with a folder and a SKILL.md file. Anthropic’s API documentation shows that every Skill requires a SKILL.md file with YAML frontmatter, including required name and description fields, followed by instructions and examples.

A simple structure looks like this:

ai-blog-editor/
├── SKILL.md
├── references/
│ ├── seo-checklist.md
│ ├── tone-guide.md
│ ├── banned-phrases.md
│ ├── wordpress-formatting.md
│ └── fact-checking-rules.md
└── examples/
├── before-after-edit.md
├── seo-brief-example.md
└── final-post-example.md

The actual value

Content editors are expensive. Good ones are very expensive. The value of a tool like this isn’t that it replaces editorial judgment — it doesn’t, and you still need someone who knows what a piece is trying to do — but that it handles the mechanical layer of the cleanup automatically.

The patterns it targets are, almost by definition, patterns that don’t require judgment to remove. Significance inflation is always worse than its absence. Copula replacements are always wrong. The -ing stacks are padding. There’s no editorial call to make there; they just need to go.

What that frees up is the actual editorial work: structure, argument, what’s missing, what’s too long, whether the conclusion lands. The stuff that does require a human.

For anyone running AI-assisted content at volume — and if you’re publishing consistently in 2025, you probably are — that separation matters. Automate the mechanical. Keep the judgment.

FAQ

What are Claude Skills?

Claude Skills are reusable instruction packages that teach Claude how to perform specific tasks or follow a specific workflow. A custom Skill generally includes a SKILL.md file with metadata and instructions, and it can also include supporting resources or scripts depending on the environment.

Can Claude Skills write blog posts automatically?

Yes, Claude Skills can help generate blog drafts, but the better use is editorial control. Use Skills to enforce structure, tone, fact-checking, visual planning, SEO rules, and publishing standards instead of simply generating more text.

Are Claude Skills better than prompt templates?

For serious workflows, yes. Prompt templates are useful, but they become bloated when you keep adding tone rules, SEO rules, examples, formatting rules, and fact-checking instructions. Skills let you organize those instructions into reusable files and focused workflows.

Do I need to code to create a Claude Skill?

Not necessarily. You can start with a folder, a SKILL.md file, and Markdown reference files. Anthropic recommends starting simple with basic Markdown instructions before adding complex scripts.

What should an AI blog editor Skill include?

An AI blog editor Skill should include your content standards, tone guide, SEO structure, fact-checking rules, formatting rules, examples of good and bad writing, and instructions for when to suggest screenshots, tables, diagrams, and internal links.

Can Claude Skills help with WordPress SEO?

Claude Skills can help prepare WordPress-ready content, including metadata, headings, FAQs, internal link suggestions, image alt text, and schema recommendations. They do not replace SEO judgment, keyword research, technical SEO, or human editorial review.

Should one Skill handle the whole blog workflow?

Usually no. A modular setup is better. Use separate Skills for content strategy, editing, fact-checking, visual planning, and WordPress formatting. Anthropic’s own best-practice guidance recommends organizing Skills by purpose rather than creating one Skill that tries to do everything.