# I built a Claude Code skill to handle the absolute nightmare of

> Source: <https://promptcube3.com/en/threads/8485/>
> Published: 2026-09-01 16:50:23+00:00

# I built a Claude Code skill to handle the absolute nightmare of

I got tired of managing four different versions of the same article, so I built a specialized AI workflow. I packaged the entire publishing lifecycle into a [Claude Code](/en/tags/claude%20code/) skill called `publishing-kit`

. Instead of manually tweaking files, you just write one clean Markdown file and tell [Claude](/en/tags/claude/) to handle the rest.

## The technical architecture of the workflow

The core idea is to separate the "intelligence" from the "execution." I use Claude Code to manage the high-level logic and decision-making, while a suite of Python scripts handles the heavy lifting that an LLM shouldn't do manually (like pixel-perfect image resizing or byte-for-byte URL verification).

**Artifact Generation:** The skill uses`make-builder.py`

,`make-medium.py`

, and`make-linkedin.py`

to transform your source Markdown into platform-specific formats. For Medium, it actually renders Markdown tables into PNG images because the Medium editor is notorious for breaking table layouts.**Automated Cover Design:** Instead of opening Photoshop,`make-cover.py`

generates the necessary assets. It renders the diagrams at every geometry the destinations demand and uses a hash-based naming convention to prevent cache issues.**Fact-Checking via Data Tracing:** This is my favorite part. The`check-facts.py`

script extracts every number, price, and version mentioned in your prose and compares them against your evidence files. It doesn't "know" if a fact is true, but it flags anything you've written from memory that doesn't appear in your source data.**The Pre-flight Check:** Before anything goes live,`preflight.py`

runs a suite of tests. It checks if the cover matches the current git HEAD, verifies geometry, ensures no hard-wrapped paragraphs exist, and performs a byte-for-byte comparison of published URLs against your local files.**API-Driven Deployment:** For platforms like dev.to, the skill uses`publish-devto.py`

to push the payload (including tags and cover) directly via API. For platforms without an API (like Medium), the skill manages the browser interaction through a checksum-verified paste method to ensure the content actually landed correctly.

## The Prompt Engineering behind the skill

To make this work, the Claude Code skill needs a very specific set of instructions. It needs to understand that "publishing" isn't just a text task—it's a deployment pipeline. Here is the core logic I used to define how Claude should interact with these tools:

```
You are an expert Technical Publishing Agent. Your goal is to take a single source Markdown file and deploy it across multiple platforms (dev.to, AWS Builder Center, Medium, and LinkedIn) using the publishing-kit toolset.

Follow this strict deployment pipeline:

1. ANALYZE: Read the source markdown and identify the technical claims (versions, prices, metrics).
2. VERIFY: Run `python check-facts.py` to ensure all extracted numbers match the provided evidence files. Fix any discrepancies in the source before proceeding.
3. BUILD: Execute the build scripts to generate platform-specific artifacts:
   - dev.to (standard markdown)
   - AWS Builder Center (emoji-stripped, disclaimer-appended)
   - Medium (HTML with tables converted to PNGs)
   - LinkedIn (short-form announcement post)
4. ASSET CHECK: Run `python make-cover.py --flow --sizes devto,builder` to generate compliant cover images.
5. PRE-FLIGHT: Run `python preflight.py --live` to validate all assets, geometry, and URL integrity.
6. DEPLOY: 
   - Use `publish-devto.py --create --org-slug [slug]` for dev.to.
   - For Medium and AWS, initiate the browser-based workflow using the provided checksum verification.
   - For LinkedIn, prepare the draft for manual review.

If any step in the pre-flight check fails, do not attempt to publish. Report the specific error and wait for my instruction to fix the source file.
```

## Why this matters for your AI workflow

The real value here isn't just automation; it's the enforcement of standards. When you treat publishing as a CI/CD pipeline for content, you stop making "human" mistakes like forgetting to update a version number or uploading a cover image that gets cropped awkwardly by a platform's feed card.

By integrating these scripts into an LLM agent like Claude Code, you move from "writing an article" to "managing a content deployment." It’s a much more robust way to handle technical communication.

[Next Stop chasing prompts and start building deterministic systems →](/en/threads/8484/)

## All Replies （0）

No replies yet — be the first!