Mixed — Solo project — review before adopting

• Last commit today
• MIT licensed
• ⚠ Solo or near-solo (1 contributor active in recent commits)
• ⚠ No CI workflows detected
• ⚠ No test directory detected
• ⚠ Scorecard: default branch unprotected (0/10)

Computed from maintenance signals — commit recency, contributor breadth, bus factor, license, CI, tests, cross-checked against OpenSSF Scorecard

A Claude Code skill that rewrites AI-generated blog posts to sound authentically human by stripping out recognizable LLM patterns (em-dash drama, hype vocabulary, rhetorical inversions) while enforcing first-person voice, concrete facts with checksums, and honest caveats. It's the blog-facing port of claude-academic-prose, applying four rule sets (voice, no-hype, no-self-sabotage, checkable claims) to catch and rewrite the telltale markers of AI-slop before publication. Flat skill structure: skills/blog-prose/ contains SKILL.md (the core rule definitions and prompt) and voice-exemplars.md (before/after examples). The .claude-plugin/ directory holds marketplace.json for skill registration. No code — purely prompt-based configuration designed to be loaded into Claude Code as an instruction set.

LLM-derived; treat as a starting point, not verified fact.

Technical writers and engineers publishing blog posts via Claude who want their AI-assisted writing to read like a knowledgeable person sharing real experience, not marketing copy — particularly those who have seen readers dismiss posts on first sight because they smell the LLM pattern.

LLM-derived; treat as a starting point, not verified fact.

Experimental / early-stage (v0.1). Single-file skill definition with no commit history, test suite, or CI visible. The project is a ported concept (following claude-academic-prose) with clear documented rules but no indicators of production use or community iteration yet.

Single-maintainer, no CI/test infrastructure, and the rule enforcement itself is untested — it's entirely Claude instruction-based with no automated validation that the rules actually fire as intended. The skill's effectiveness depends on Claude's instruction-following consistency, which can vary. No issue tracker or roadmap visible.

LLM-derived; treat as a starting point, not verified fact.

The repo appears to be a freshly published initial release. No active commit history, PRs, or issue tracking visible — this is a stable snapshot of the port from academic-prose to blog context, with the four rule sets documented and exemplified but awaiting real-world feedback and iteration.

LLM-derived; treat as a starting point, not verified fact.

Clone and inspect the skill definitions: git clone https://github.com/sjmoran/claude-blog-prose && cd claude-blog-prose && cat skills/blog-prose/SKILL.md. The skill is meant to be loaded into Claude Code via the .claude-plugin/marketplace.json registration, not run locally as a traditional project.

Daily commands: Not a runnable project. Load it as a Claude Code skill: paste the rules from skills/blog-prose/SKILL.md into a Claude conversation with code context enabled, or register via .claude-plugin/marketplace.json if using Claude Code's plugin system. Use by running a blog draft through Claude with the skill context applied.

• README.md — Entry point explaining the skill's purpose, philosophy, and the core problem it solves (stripping AI-generated blog-post clichés).
• skills/blog-prose/SKILL.md — Primary skill definition and rules that Claude will apply when generating blog prose — the load-bearing configuration.
• skills/blog-prose/voice-exemplars.md — Concrete before/after examples and voice patterns showing what acceptable blog prose looks like in this skill's view.
• .claude-plugin/marketplace.json — Metadata and registration for Claude Code plugin discovery and integration.
• .gitignore — Standard exclusion rules for the repository.

• SKILL.md (Rules Engine) (Markdown prose) — Defines hard constraints (avoid em-dash drama, no jargon, first-person) and soft heuristics (checkability, authorial voice) for prose quality.
  • Failure mode: Rules are ambiguous or contradictory, leading Claude to misinterpret intent on edge cases.
• voice-exemplars.md (Training Data) (Markdown exemplars) — Provides before/after examples that ground Claude's understanding of rule violations and acceptable rewrites.
  • Failure mode: Exemplars are narrow or unrepresentative; Claude overgeneralizes or fails on novel prose patterns.
• marketplace.json (Integration Metadata) (JSON configuration) — Registers the skill with Claude Code, enabling discovery and installation.
  • Failure mode: Metadata is outdated or malformed; skill fails to load or appears with incorrect metadata in marketplace.
• README.md (Philosophy & Context) (Markdown documentation) — Explains the skill's purpose, rationale, and relationship to its academic predecessor, so users understand when and how to apply it.
  • Failure mode: Users misunderstand scope or misapply the skill to non-blog contexts (e.g., marketing copy, technical docs).

• User draft blog post → Claude (via Claude Code) — User paste their draft or references a file; Claude Code loads the skill.
• SKILL.md + voice-exemplars.md → Claude inference engine — Claude ingests rules and exemplars to contextualize the rewrite task.
• Claude reasoning → Rewritten blog prose — Claude applies rules to the draft, removing clichés and rewriting for authenticity and checkability.
• Rewritten prose → User feedback — User reviews the output, iterates, and may contribute improved rules or exemplars back to the repo.

Add a new prose rule or constraint

1. Open SKILL.md and locate the rules section where constraints are listed. (skills/blog-prose/SKILL.md)
2. Add a new rule entry following the existing pattern (e.g., 'Avoid X, prefer Y'), with clear rationale. (skills/blog-prose/SKILL.md)
3. Create a before/after exemplar pair in voice-exemplars.md to illustrate the new rule in action. (skills/blog-prose/voice-exemplars.md)

Add new voice exemplars or patterns

1. Open voice-exemplars.md and review existing before/after pairs to match the style. (skills/blog-prose/voice-exemplars.md)
2. Add a new exemplar section with a problematic LLM-generated snippet and the desired honest rewrite. (skills/blog-prose/voice-exemplars.md)
3. Tag the exemplar with relevant rule categories (e.g., 'em-dash drama', 'jargon', 'checkability') so it reinforces the skill rules. (skills/blog-prose/voice-exemplars.md)

Update plugin metadata for marketplace

1. Open marketplace.json and review current skill metadata (name, version, description, tags). (.claude-plugin/marketplace.json)
2. Update version, description, or tags to reflect any changes to the skill's capabilities or focus. (.claude-plugin/marketplace.json)

• Markdown + Plain Text — Skill rules and exemplars are stored as human-readable Markdown for easy review, versioning, and contribution; no complex serialization.
• Claude Code Plugin Framework — Delivers the skill as a Claude Code integration so writers can invoke it directly during composition without context-switching.
• Marketplace JSON — Standard metadata format for plugin discovery and integration, reducing friction for users finding and installing the skill.

• Rules are declarative prose, not formal grammar or DSL.

  • Why: Easier for humans (writers, reviewers) to understand and debate; lowers contribution barriers.
  • Consequence: Claude must interpret rules from natural language; ambiguity in edge cases requires exemplars to disambiguate.

• Skill is voice-centric (exemplars), not purely mechanical (e.g., regex filters).

  • Why: Honest prose often requires semantic judgment, not just keyword blacklisting; exemplars teach nuance.
  • Consequence: Requires Claude to reason about intent and context; less suitable for fully automated copy-editing pipelines.

• No runtime infrastructure (no API, no database, no monitoring).

  • Why: Skill is a static guidance layer for Claude; users run the skill locally in Claude Code.
  • Consequence: No telemetry or feedback loop to refine rules; improvements are manual and community-driven.

• Does not enforce grammar or spelling; assumes input is already syntactically sound.
• Does not handle fact-checking or citation; flags claims as 'checkable' but does not verify them.
• Does not apply SEO or engagement optimization; explicitly rejects metrics-driven writing.
• Does not provide automated editing; gives rules and examples for human writers to apply with Claude's help.
• Does not replace domain expertise; assumes the writer knows their subject.

• Avg cyclomatic complexity: ~2 — Skill is lightweight; no algorithms, no state management, no API calls. Complexity is purely semantic (interpreting prose rules).
• Largest file: skills/blog-prose/voice-exemplars.md (250 lines)
• Estimated quality issues: ~1 — No automated tests or validation; relies entirely on human review and Claude's interpretation. No linting or type checking.

• Rules without exemplars (Medium) — skills/blog-prose/SKILL.md: If a rule lacks a corresponding before/after example in voice-exemplars.md, Claude may misinterpret or overapply it.
• Aspirational exemplars (unrealistic rewrites) (Medium) — skills/blog-prose/voice-exemplars.md: If exemplars show impossibly clean or overly edited versions, Claude may either overcorrect or ignore the rule entirely.

• voice-exemplars.md comprehensiveness (Maintenance & Coverage) — Exemplars are static; as LLM writing styles evolve, new clichés emerge that aren't captured.
• Rule clarity & ambiguity (Semantic Ambiguity) — Some rules (e.g., 'first-person voice') are subjective; edge cases (e.g., when to use 'we' vs. 'I') require interpretation.
• No feedback loop for rule refinement (Observability) — There is no runtime data on which rules are most effective or frequently violated; improvements are guesswork.

This is a skill, not a software library — there is no install step, no runtime, no config file to set. It lives entirely as prose instructions in SKILL.md. The enforcement happens via Claude's language understanding, not code execution, so effectiveness depends on the exact phrasing of the rules and Claude's consistency at following them. No automated way to verify the skill is working; you must manually check output. The skill assumes you're using Claude Code with code context enabled — standard Claude chat or other frontends won't have it available.

• Lexical hedging and intensifier detection — The 'no-hype' rule set targets specific linguistic markers (em-dashes, adverbs like 'truly', 'delve', 'leverage') that signal AI-written prose; understanding what they are helps you refine the rule set.
• First-person narrative voice in technical writing — blog-prose enforces first-person and concrete detail to build reader trust; knowing why this voice works in technical contexts helps you evaluate when to apply the skill.
• Checkable claims and verification — Rule 4 of blog-prose requires every factual claim be verifiable in <1 minute (benchmarks, linked sources, code diffs); this principle underpins credibility and distinguishes human technical writing from marketing.
• LLM output patterns and detection — The entire skill is built on recognizing and stripping predictable LLM artifacts (triadic punchlines, 'not X — it's Y' pivots, withholding titles); understanding these patterns helps you spot them in your own writing.
• Caveat and uncertainty expression — The 'no-self-sabotage' rule distinguishes between honest caveats ('I'm not sure this holds under concurrent writes') and false modesty ('I'm no expert but'); knowing the difference keeps your work credible without underselling.
• Rhetorical inversion and pivots — Structures like 'It's not X — it's Y' and 'delve into' are specifically banned in blog-prose because they delay the point and feel manufactured; recognizing them in drafts helps you rewrite for directness.

• sjmoran/claude-academic-prose — The direct predecessor — the academic-paper version of this skill with similar rule sets for research writing; blog-prose is the lighter, first-person port.
• AnthropicAI/anthropic-sdk-python — Claude's official Python SDK; use it to programmatically invoke Claude with the blog-prose skill context if automating bulk blog rewrites.
• zeke/claude-code-skills — A community index of Claude Code skills; blog-prose would be discoverable and comparable against other writing-aid skills if listed here.
• boz/clever-commit-messages — Related LLM-rewriting skill for commit message prose — applies similar anti-hype, clarity-first principles to version control messages.
• Anthropic/prompt-eng-resources — Anthropic's official prompt-engineering guides; useful reference for understanding how to refine the rule sets in SKILL.md for clarity and effectiveness.

• Add a test-cases.md file with 10–15 real blog post excerpts (both LLM-default and manually rewritten versions) that contributors can use to validate whether SKILL.md rules fire correctly. Include category labels (e.g., 'em-dash chains', 'hype vocabulary', 'checkable claims') for each pair.
• Expand voice-exemplars.md with 3–5 additional worked examples in different domains (infrastructure, frontend, data science) to show how blog-prose rules apply beyond the caching example. Include annotations explaining which rule fires at each step.
• Create a CONTRIBUTING.md documenting how to propose new rules or refine existing ones, with a process for testing rule clarity against Claude's outputs and filing observations as issues.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub