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

Publishing a single technical deep dive to four different platforms is a massive waste of engineering time. You aren't just "copy-pasting"; you are fighting specific platform quirks: Medium's importer destroys Markdown tables, AWS Builder Center hates emojis, dev.to has weird aspect ratio requirements for covers, and LinkedIn requires a completely different tone for the announcement post.

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 skill called publishing-kit. Instead of manually tweaking files, you just write one clean Markdown file and tell 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.