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 usesmake-builder.py
,make-medium.py
, andmake-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. Thecheck-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 usespublish-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 up 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 →
All Replies （0） #
No replies yet — be the first!