Code & Connect (Part 3): Creating a Content-Automation Mini-Bot

The Unscripted Journey of Automation: Why We Built a Mini-Bot

​At My Gemini Journey, our mission is to explore and demystify the power of Human-AI partnership. A core challenge for any growing content brand is the immense effort and management required to ensure cross-platform consistency. We set out to tackle this head-on by building a Content-Automation Mini-Bot—a small Python script designed to instantly amplify our new Blogspot articles on X (formerly Twitter).

​The motivation was simple: eliminate redundant manual effort. Every time a new article, like the recent article "The Unassailable AI Niche", went live, one of us had to stop what we were doing, draft a tweet, and post the link. The Mini-Bot was designed to automate this entire workflow, ensuring maximum reach with minimal human intervention.

The Blueprint: Code Details and Core Functionality

​Our Human-AI partnership drafted a workflow that was both logical and scalable, relying on the Python libraries feedparser (for RSS) and tweepy (for X interaction).

• Human (Management): Defined the logic to prevent duplicate posts and created the project brief.

• AI (Effort) Wrote the base code for fetching, logging, and API connection attempts.

1. The Brain: The Fetch & Log Function

​The bot's "memory" is a log file (posted_articles.txt) and its "eyes" read the RSS feed. This function ensures the bot only posts new content, avoiding repetition.

​The Core Code Snippet (get_new_article):

# Part 1: Finding New Content

def get_new_article():

# Load the log of previously posted links

try:

with open('posted_articles.txt', 'r') as f:

posted_links = f.read().splitlines()

except FileNotFoundError:

posted_links = []

        

# Parse the Blogspot RSS Feed

feed = feedparser.parse('https://mygeminijourney.blogspot.com/feeds/posts/default?alt=rss')

    

# Check the newest articles for unposted links

for entry in feed.entries:

article_link = entry.link

        

if article_link not in posted_links:

# New article found!

return entry

return None

2. The Action: The X Posting Function

​This function's purpose was to craft an immediate, engaging tweet using our X Thread Workflow (concise text + pertinent hashtags), then handle the communication with the X API to publish the post.

​The Core Code Snippet (Attempted post_article_to_x):

# Part 2: Posting the Article (The Blocked Logic)

def post_article_to_x(article):

# Using the robust (but often challenging) OAuth 1.0a User Context

auth = tweepy.OAuth1UserHandler(

CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET

)

client = tweepy.API(auth)

    

# Crafting the message following the 'My Gemini Journey' X style

tweet_text = f"New AI Content Blueprint! 🚀\n\n{article.title}\n\nRead the full post here: {article.link}\n\n#MyGeminiJourney #AIPoweredContent #EthicalAI"

    

# Attempting to post the update

client.update_status(tweet_text) 

    

# Logging the link immediately upon success

with open('posted_articles.txt', 'a') as f:

f.write(article.link + '\n')

    

return True

Project On Hold: Transparency in Technical Roadblocks

​Despite having a complete and logically sound script, both the Content Automation Mini-Bot and the New Follower Welcoming Bot are currently in a pending state, held captive by the same issue: API Authentication.

• The Problem: The Dreaded 403 Forbidden Error. When the Mini-Bot attempted to run its posting function, the X API immediately returned a 403 Forbidden error with the message: “Your client app is not configured with the appropriate oauth1 app permissions for this endpoint.”

• ​The Technical Reality: We confirmed our X Developer App permissions were set to "Read and Write" and regenerated our tokens. However, the problem is a mismatch between the tokens we are using and the API client configuration. This is a recurring complexity in the transition between the old Twitter API (v1.1) and the current X API (v2).

• ​The API Conundrum: The specific error indicates our tokens, despite the correct permissions, are not properly authenticating the 'write' action required to post a tweet. This technical gap requires a pivot: switching to newer v2-specific keys (like a Bearer Token) or finding a simple example of a fully working OAuth 1.0a connection that bypasses this block.

The Management Decision

​As Human Strategist, we had to manage the effort efficiently. Since both the "Content Automation Mini-Bot" and the "New Follower Welcoming Bot" share the same core problem—the X API authentication block—it was strategically sound to pause development on both.

• ​Rationale: We are pooling our effort and management focus into researching the most stable way to perform a write action on the X API. Once this fundamental authentication key-point is solved for one bot, the solution will immediately be applied to the other, unlocking both projects simultaneously.

​This pause is a demonstration of responsible project management—we halt execution before committing more time to a technically blocked path, ensuring our energy is instead directed toward finding a permanent solution.

​We will keep you updated as we pursue the new authentication blueprint. The code is written; the final key is just waiting to be turned.

Until then, we will continue our journey to discover other sides of this alliance... Stay tuned!