Single Source, Multi-Platform -> Makefile as Publishing Engine

The Problem

I write in one place. Readers are everywhere.

I update content. Old versions live forever on different platforms.

I publish manually. Time dies with each copy-paste.

The Discovery

My content lives in Git. That's the single source of truth.

GitBook reads from Git. dev.to can read from Git. Medium can read from Git. Everything can read from Git.

So why am I copy-pasting?

The Architecture

Git (Source of Truth)
    ↓
GitHub (Version Control)
    ↓
GitBook (Primary Interface) 
    ↓
Makefile (Publishing Engine)
    ├-> dev.to
    ├-> Medium
    ├-> Hashnode
    └-> Anywhere

One source. Infinite destinations.

The Implementation

State Management Without Database

# .clarity/devto-articles.json
{
  "article-name": "2829234",  # dev.to article ID
  "another-one": "2829233"
}

# .clarity/devto-checksums.json  
{
  "article-name": "a3f5b2c8d9e1f4g6",  # MD5 hash
  "another-one": "b4g6c3d0e2f5a7h8"
}

No database. Just JSON files. Git tracks them. Simple.

Change Detection Without Complexity

CURRENT_CHECKSUM=$(md5 -q article.md)
SAVED_CHECKSUM=$(jq -r '.article' .clarity/devto-checksums.json)

if [ "$CURRENT_CHECKSUM" = "$SAVED_CHECKSUM" ]; then
    echo "[OK] No changes, skipping"
else
    # Update only what changed
fi

MD5 hash comparison. File changed? Update. File same? Skip.

Platform Differences as Features

GitBook uses `` tags. dev.to doesn't understand them.

Solution? Strip them during publish:

`makefile
CONTENT=$(cat article.md | sed 's///g')
`

Each platform has its reality. Adapt, don't fight.

The Workflow

1. Write in Markdown (Git)
2. Push to GitHub
3. GitBook auto-updates (webhook)
4. Run make sync-devto
5. All platforms updated

One command. All platforms synced.

Real Examples from My System

Creating New Article

`bash

Write locally

code docs/claude-ai-vibe-coding/new-article.md

Push to Git

git add . && git commit -m "new article" && git push

Sync everywhere

make sync-devto # Updates or creates as needed
`

Updating Existing Article

`bash

Edit locally

code existing-article.md

System detects changes via MD5

make sync-devto

Output: [OK] Article Name - No changes, skipping

or

Output: -> Updating: Article Name (ID: 2829234)

`

Rate Limiting? Solved

`makefile
if [ "$HTTP_CODE" = "429" ]; then
echo "Rate limit. Waiting 35 seconds..."
sleep 35
$(MAKE) retry
fi
`

Patience as code. Not error handling, feature implementation.

Why Makefile?

I used GitHub Actions. Then I woke up.

GitHub Actions = Their computer, their rules, their time.
Makefile = My computer, my rules, my time.

`makefile

This runs on MY machine

publish:
@echo "I control this"

This runs on THEIR machine

.github/workflows/publish.yml

I wait, I hope, I pray

`

Control matters more than convenience.

The Philosophy

Single Source of Truth: Git. Not Notion, not Google Docs. Git.

Platform Agnostic: Write once, publish everywhere.

Automation Over Memory: I don't remember to update. Code remembers for me.

State Without Database: JSON files in .clarity/. Git tracks them. Done.

Adapt, Don't Force: Each platform is different. Transform content to fit.

Pattern Recognition

This isn't about blogging. It's about:

1. Information Flow: One source -> Many destinations
2. State Management: Local files > Remote databases
3. Change Detection: Checksums > Timestamps
4. Platform Reality: Transform > Complain
5. Control: Makefile > CI/CD services

Start Your Own

`makefile

Minimal viable publisher

sync:
@for article in docs/*.md; do \
if [ file_changed ]; then \
curl -X POST platform.com/api \
-d "$$(cat $$article)"
fi
done
`

Expand from here. Add state. Add checksums. Add platforms.

The Result

• Write once, publish everywhere
• No manual updates
• No forgotten platforms
• No version mismatches
• Full control

My blog is everywhere. My time is mine.

Conclusion

Stop logging into platforms. Stop copy-pasting. Stop remembering to update.

Write in Git. Let Makefile handle the rest.

Publishing isn't about platforms. It's about flow.

Git -> Makefile -> World.

That's it. That's the system.

---

Part of the Zero Documentation -> Living Code philosophy. See also: Git as Evolution Engine - how commits become learning.

---

Read the original: Single Source, Multi-Platform -> Makefile as Publishing Engine