DEV Community: Joey Umanito

Agentic Coding in 2026: How AI Agents Are Running Your Codebase

Joey Umanito — Tue, 10 Mar 2026 01:39:32 +0000

Imagine waking up, grabbing your coffee, and finding that your AI coding agent already reviewed last night's pull requests, flagged three potential bugs, and posted a summary to your Slack — all without you lifting a finger. That's not sci-fi anymore. That's agentic coding in 2026, and it's changing how developers work faster than most of us expected.

Why Agentic Coding Is the Biggest Dev Trend Right Now

Just a year ago, AI coding assistants were mostly autocomplete on steroids. You'd type a comment, the AI would suggest a function, you'd tweak it, move on. Useful — but still very human-driven.

That model is being replaced. Fast.

Claude Code (released May 2025) has already overtaken GitHub Copilot and Cursor as the most-used AI coding tool, in just eight months. Meanwhile, Cursor — which hit $2 billion in annual recurring revenue in early March 2026 (doubling in just three months) — just launched a new feature called Automations that takes things even further.

These tools aren't just completing your code anymore. They're running your codebase.

What Is Agentic Coding, Exactly?

Traditional AI coding tools follow a prompt-and-monitor loop:

You write a prompt
The AI generates code
You review and repeat

Agentic coding flips this. Instead of waiting for your input, AI agents:

Watch for triggers (new commits, Slack messages, PagerDuty alerts, timers)
Take action automatically (run tests, security audits, write summaries)
Loop you in only when needed

As Cursor's engineering lead Jonas Nelle put it: "It's not that humans are completely out of the picture. It's that they aren't always initiating. They're called in at the right points in this conveyor belt."

Key Agentic Coding Tools You Should Know

1. Cursor Automations

Cursor's new Automations system lets you define always-on agents triggered by:

New code pushed to a branch
Incoming Slack messages
Scheduled timers

One built-in example is Bugbot — it automatically reviews every new addition to your codebase for bugs and security issues. No manual code review trigger needed.

Cursor reports running hundreds of automations per hour internally, including automated incident response (PagerDuty → agent queries server logs via MCP) and weekly codebase summary Slackbots.

2. Claude Code

Anthropic's Claude Code is a CLI-first tool that lives in your terminal and has deep context of your entire codebase. It can:

Execute terminal commands
Run your test suite
Edit files across multiple directories
Plan and complete multi-step tasks autonomously

Claude Code recently added voice mode, letting you literally talk to your coding agent while you work.

3. OpenAI Codex (with dedicated chip)

OpenAI's updated Codex now runs on a dedicated inference chip, making it significantly faster for long-horizon coding tasks.

A Practical Example: Setting Up an Auto Code Review Agent

Here's a simplified example of how you'd set up a basic automated code review workflow using Python and a webhook trigger:

# auto_review.py - Triggered on new GitHub push event
import anthropic
import json

def review_code_changes(diff: str) -> str:
    client = anthropic.Anthropic()

    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"""Review this code diff for bugs, security issues, 
                and performance problems. Be concise and actionable.

                Diff:
                {diff}"""
            }
        ]
    )
    return message.content[0].text

# Webhook handler (Flask/FastAPI)
def handle_github_push(payload: dict):
    diff = payload.get("diff", "")
    if diff:
        review = review_code_changes(diff)
        post_to_slack(review)  # Send result to Slack channel
        return {"status": "reviewed", "feedback": review}

This is the foundation of what Cursor Automations and similar tools do under the hood — agents triggered by events, taking action, reporting back.

What This Means for Developers in 2026

Here's the shift happening right now:

Old Model	Agentic Model
You prompt → AI responds	Event triggers → Agent acts
One task at a time	Dozens of parallel agent tasks
You review everything	Agent flags only what matters
You run tests	Agent runs + reports tests

Senior engineers are becoming "agent orchestrators" — designing systems of agents rather than writing every line themselves. Junior developers are learning faster because agents give instant feedback on every commit.

The developers who thrive will be those who learn to design agent workflows, not just write code.

How to Get Started Today

Try Cursor Automations — if you use Cursor, the Automations feature is rolling out now. Set up a Bugbot automation on your main branch.
Experiment with Claude Code — install it via npm install -g @anthropic-ai/claude-code and try running it on a real project.
Build your own lightweight agent — use the Python example above with Anthropic's API and a simple webhook to automate your own code reviews.
Study MCP (Model Context Protocol) — this is how agents connect to your tools (GitHub, Slack, databases). Understanding MCP will be a core developer skill in 2026.

The future of coding isn't humans vs AI. It's humans directing AI agents at scale — and the developers who master that skill are going to have a serious edge.

Need help implementing this in your project?

I'm available for hire! I build custom AI chatbots, REST APIs, WhatsApp/Telegram bots, and AI-powered tools for businesses.

🤖 AI Chatbot Development — Starting $20
🔌 REST API Development — Starting $20
💬 WhatsApp/Telegram Bot — Starting $20
✍️ AI Content Generation — Starting $20

Support my work on Ko-fi ☕

Getting Started with Agentic AI: Your 2026 Developer Guide

Joey Umanito — Wed, 04 Mar 2026 07:41:52 +0000

Agentic AI is transforming how developers build intelligent systems in 2026.## Why Agentic AI MattersUnlike traditional chatbots that respond to user input, AI agents actively observe their environment, reason about goals, choose tools strategically, and execute multi-step workflows with minimal human oversight.For developers, this opens opportunities to:- Automate complex, multi-step workflows- Build smarter applications that adapt in real-time- Create new revenue streams with AI-powered solutions- Improve productivity by offloading operational tasks## Key Components to Build Agents### 1. Choose Your LLM Wisely- GPT-5: Best for general reasoning (128K context)- Claude Sonnet 4.5: Excel at agentic workflows (200K context)- Gemini 2.5 Pro: Fastest for multimodal (1M context)- LLaMA 4: Open-source for privacy (10M context)Pro tip: Route 70% of routine tasks to cheaper models and reserve flagship models for complex tasks.### 2. Define Clear ScopeMost agents fail by trying to do too much. Start narrow:- Define the specific problem- Set success KPIs- Determine autonomy level### 3. Build a Smart System PromptYour prompt should include:- Clear goals- Role/Persona- Step-by-step instructions- Guardrails### 4. Equip Your Agent with ToolsTools let agents interact with the real world:- API calls- Function execution- Web browsing- Code executionUse Model Context Protocol (MCP) - the standard for AI integrations.### 5. Implement Persistent MemoryLLMs have no memory between calls:- Short-term: Conversation history- Working: Current state (JSON)- Long-term: Vector databases (Pinecone, Weaviate)- Structured: SQL databases## Key Takeaways1. Agentic AI is the future2. Start narrow, then scale3. Tools and integrations matter4. Prompt engineering is an art5. Test rigorously before productionYou don't need a PhD to build useful agents - just clarity, the right tools, and disciplined engineering.---Need help implementing this?I'm available for hire! I build custom AI chatbots, REST APIs, WhatsApp/Telegram bots, and AI-powered tools. AI Chatbot Development - Starting $20 REST API Development - Starting $20 WhatsApp/Telegram Bot - Starting $20 AI Content Generation - Starting $20Support my work on Ko-fi

Web Scraping with Python: BeautifulSoup and Selenium Guide 2025

Joey Umanito — Fri, 27 Feb 2026 02:52:50 +0000

Web scraping is one of the most useful skills a developer can have. From price monitoring to lead generation, data collection powers countless applications. Here's how to do it right.

Two Approaches

BeautifulSoup — for static HTML pages (fast, simple)
Selenium — for JavaScript-rendered pages (handles dynamic content)

BeautifulSoup: Static Pages

pip install requests beautifulsoup4 lxml

import requests
from bs4 import BeautifulSoup
import json
import time

def scrape_articles(url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }

    response = requests.get(url, headers=headers)
    soup = BeautifulSoup(response.content, 'lxml')

    articles = []
    for article in soup.find_all('article'):
        title = article.find('h2')
        link = article.find('a')
        description = article.find('p')

        if title and link:
            articles.append({
                "title": title.get_text(strip=True),
                "url": link.get('href'),
                "description": description.get_text(strip=True) if description else ""
            })

    return articles

results = scrape_articles("https://news.ycombinator.com")
print(json.dumps(results[:5], indent=2))

Handling Pagination

def scrape_all_pages(base_url, max_pages=10):
    all_data = []

    for page in range(1, max_pages + 1):
        url = f"{base_url}?page={page}"
        response = requests.get(url)

        if response.status_code != 200:
            break

        soup = BeautifulSoup(response.content, 'lxml')
        items = soup.find_all('div', class_='item')

        if not items:
            break

        for item in items:
            all_data.append(item.get_text(strip=True))

        time.sleep(1)  # Be respectful

    return all_data

Selenium: Dynamic JavaScript Pages

pip install selenium webdriver-manager

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from webdriver_manager.chrome import ChromeDriverManager

def setup_driver(headless=True):
    options = webdriver.ChromeOptions()
    if headless:
        options.add_argument('--headless')
    options.add_argument('--no-sandbox')
    options.add_argument('--disable-dev-shm-usage')

    driver = webdriver.Chrome(
        service=webdriver.ChromeService(ChromeDriverManager().install()),
        options=options
    )
    return driver

def scrape_dynamic_page(url):
    driver = setup_driver()

    try:
        driver.get(url)

        wait = WebDriverWait(driver, 10)
        content = wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, 'content'))
        )

        # Scroll to load lazy content
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        time.sleep(2)

        items = driver.find_elements(By.CSS_SELECTOR, '.item')
        return [item.text for item in items]

    finally:
        driver.quit()

Saving Scraped Data

import pandas as pd

def save_to_csv(data, filename):
    df = pd.DataFrame(data)
    df.to_csv(filename, index=False)
    print(f"Saved {len(data)} records to {filename}")

def save_to_json(data, filename):
    with open(filename, 'w') as f:
        json.dump(data, f, indent=2)

Rate Limiting and Ethics

import random

def polite_request(url, min_delay=1, max_delay=3):
    time.sleep(random.uniform(min_delay, max_delay))

    response = requests.get(url, headers={
        "User-Agent": "My Research Bot/1.0 (contact@example.com)"
    })

    return response

Always:

Check robots.txt before scraping
Add delays between requests
Respect rate limits
Don't scrape personal data without permission

Use Cases That Pay

Price monitoring for e-commerce
Lead generation from directories
Competitive analysis for businesses
Real estate listings aggregation
Job board scraping for recruitment

Need Automated Data Collection?

Have a scraping or automation project in mind?

Python Automation Services - Custom scrapers from $20
AI Content Generation - Automated data pipelines from $20

What data are you trying to collect? Ask in the comments!

Web Scraping with Python: BeautifulSoup and Selenium Guide 2025

Joey Umanito — Fri, 27 Feb 2026 02:47:03 +0000

Web scraping is one of the most useful skills a developer can have. From price monitoring to lead generation, data collection powers countless applications. Here's how to do it right.

Two Approaches

BeautifulSoup — for static HTML pages (fast, simple)
Selenium — for JavaScript-rendered pages (handles dynamic content)

BeautifulSoup: Static Pages

pip install requests beautifulsoup4 lxml

import requests
from bs4 import BeautifulSoup
import json

def scrape_articles(url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }

    response = requests.get(url, headers=headers)
    soup = BeautifulSoup(response.content, 'lxml')

    articles = []
    for article in soup.find_all('article'):
        title = article.find('h2')
        link = article.find('a')
        description = article.find('p')

        if title and link:
            articles.append({
                "title": title.get_text(strip=True),
                "url": link.get('href'),
                "description": description.get_text(strip=True) if description else ""
            })

    return articles

results = scrape_articles("https://news.ycombinator.com")
print(json.dumps(results[:5], indent=2))

Extracting Specific Data

def scrape_product_info(url):
    soup = BeautifulSoup(requests.get(url).content, 'lxml')

    return {
        "name": soup.select_one('h1.product-title')?.get_text(strip=True),
        "price": soup.select_one('.price')?.get_text(strip=True),
        "rating": soup.select_one('[data-rating]')?.get('data-rating'),
        "images": [img['src'] for img in soup.select('.product-image img')]
    }

Handling Pagination

def scrape_all_pages(base_url, max_pages=10):
    all_data = []

    for page in range(1, max_pages + 1):
        url = f"{base_url}?page={page}"
        response = requests.get(url)

        if response.status_code != 200:
            break

        soup = BeautifulSoup(response.content, 'lxml')
        items = soup.find_all('div', class_='item')

        if not items:  # No more results
            break

        for item in items:
            all_data.append(item.get_text(strip=True))

        time.sleep(1)  # Be respectful

    return all_data

Selenium: Dynamic JavaScript Pages

pip install selenium webdriver-manager

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from webdriver_manager.chrome import ChromeDriverManager

def setup_driver(headless=True):
    options = webdriver.ChromeOptions()
    if headless:
        options.add_argument('--headless')
    options.add_argument('--no-sandbox')
    options.add_argument('--disable-dev-shm-usage')

    driver = webdriver.Chrome(
        service=webdriver.ChromeService(ChromeDriverManager().install()),
        options=options
    )
    return driver

def scrape_dynamic_page(url):
    driver = setup_driver()

    try:
        driver.get(url)

        # Wait for content to load
        wait = WebDriverWait(driver, 10)
        content = wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, 'content'))
        )

        # Scroll to load lazy content
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        time.sleep(2)

        # Extract data
        items = driver.find_elements(By.CSS_SELECTOR, '.item')
        return [item.text for item in items]

    finally:
        driver.quit()

Saving Scraped Data

import pandas as pd

# Save to CSV
def save_to_csv(data, filename):
    df = pd.DataFrame(data)
    df.to_csv(filename, index=False)
    print(f"Saved {len(data)} records to {filename}")

# Save to JSON
def save_to_json(data, filename):
    with open(filename, 'w') as f:
        json.dump(data, f, indent=2)

Rate Limiting and Ethics

import time
import random

def polite_request(url, min_delay=1, max_delay=3):
    """Be a good web citizen"""
    time.sleep(random.uniform(min_delay, max_delay))

    response = requests.get(url, headers={
        "User-Agent": "My Research Bot/1.0 (contact@example.com)"
    })

    return response

Always:

Check robots.txt before scraping
Add delays between requests
Respect rate limits
Don't scrape personal data without permission

Use Cases That Pay

Price monitoring for e-commerce
Lead generation from directories
Competitive analysis for businesses
Real estate listings aggregation
Job board scraping for recruitment

Need Automated Data Collection?

Have a scraping or automation project in mind?

Python Automation Services - Custom scrapers from $20
AI Content Generation - Automated data pipelines from $20

What data are you trying to collect? Ask in the comments!

Docker for Python Developers: From Zero to Containerized App

Joey Umanito — Fri, 27 Feb 2026 02:41:13 +0000

Docker changed how we deploy applications. No more "it works on my machine" problems. Here's everything a Python developer needs to know to get started with Docker.

Why Docker?

Before Docker:

"Works on my machine"
Complex environment setup
Dependency conflicts
Hard to scale

With Docker:

Consistent environments everywhere
One command setup
Isolated dependencies
Easy horizontal scaling

Your First Dockerfile

# Dockerfile
FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Copy requirements first (for layer caching)
COPY requirements.txt .

# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose port
EXPOSE 8000

# Run the application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Sample FastAPI App

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello from Docker!"}

@app.get("/health")
def health_check():
    return {"status": "healthy"}

# requirements.txt
fastapi==0.104.1
uvicorn==0.24.0

Build and Run

# Build the image
docker build -t my-python-app .

# Run the container
docker run -p 8000:8000 my-python-app

# Run in background (detached)
docker run -d -p 8000:8000 my-python-app

# View running containers
docker ps

# Stop a container
docker stop <container_id>

Docker Compose for Multi-Service Apps

# docker-compose.yml
version: '3.8'

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/mydb
    depends_on:
      - db
    volumes:
      - .:/app

  db:
    image: postgres:15
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

# Start all services
docker-compose up

# Start in background
docker-compose up -d

# Stop all services
docker-compose down

Essential Docker Commands

# Images
docker images                    # List images
docker pull python:3.11-slim     # Pull image
docker rmi my-image              # Remove image

# Containers
docker ps -a                     # List all containers
docker logs <container_id>       # View logs
docker exec -it <id> /bin/bash   # Shell into container
docker rm <container_id>         # Remove container

# Cleanup
docker system prune              # Remove unused resources

Environment Variables

import os

# In your Python app
DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///default.db")
API_KEY = os.getenv("API_KEY", "")
DEBUG = os.getenv("DEBUG", "False").lower() == "true"

# Pass env vars when running
docker run -e API_KEY=your_key -e DEBUG=true my-app

# Use .env file
docker run --env-file .env my-app

Production Best Practices

# Multi-stage build for smaller images
FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Free Hosting Options

Railway.app: Deploy Docker containers free
Render.com: Free tier for containerized apps
Fly.io: Generous free tier
Google Cloud Run: Pay only when running

Need Help Containerizing Your App?

Already have a Python application but struggling with deployment?

REST API Development - Deploy-ready APIs from $20
AI Chatbot Development - Containerized AI chatbots from $20

What Python apps are you containerizing with Docker? Share below!

How to Build a Real-Time Chat App with Python and WebSockets

Joey Umanito — Fri, 27 Feb 2026 02:40:32 +0000

Real-time features are everywhere: live chat, notifications, collaborative editing. WebSockets make this possible, and Python makes it easy. Let's build a real-time chat application from scratch.

What We're Building

A simple chat room where multiple users can send and receive messages instantly — no page refresh needed.

Setup

pip install websockets asyncio

The Server (server.py)

import asyncio
import websockets
import json
from datetime import datetime

# Store connected clients
connected_clients = set()

async def handle_client(websocket, path):
    # Register new client
    connected_clients.add(websocket)
    print(f"New client connected. Total: {len(connected_clients)}")

    try:
        async for message in websocket:
            data = json.loads(message)

            # Broadcast to all connected clients
            broadcast_message = json.dumps({
                "user": data.get("user", "Anonymous"),
                "message": data.get("message", ""),
                "timestamp": datetime.now().strftime("%H:%M:%S")
            })

            # Send to all clients except sender
            await asyncio.gather(
                *[client.send(broadcast_message) 
                  for client in connected_clients 
                  if client != websocket]
            )
    except websockets.exceptions.ConnectionClosed:
        pass
    finally:
        connected_clients.remove(websocket)
        print(f"Client disconnected. Total: {len(connected_clients)}")

async def main():
    async with websockets.serve(handle_client, "localhost", 8765):
        print("WebSocket server running on ws://localhost:8765")
        await asyncio.Future()  # Run forever

if __name__ == "__main__":
    asyncio.run(main())

The Client (client.html)

<!DOCTYPE html>
<html>
<head>
    <title>Real-Time Chat</title>
    <style>
        body { font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; }
        #messages { height: 400px; overflow-y: scroll; border: 1px solid #ccc; padding: 10px; }
        .message { margin: 5px 0; padding: 8px; background: #f0f0f0; border-radius: 4px; }
        input { width: 70%; padding: 10px; }
        button { padding: 10px 20px; background: #007bff; color: white; border: none; cursor: pointer; }
    </style>
</head>
<body>
    <h2>Real-Time Chat Room</h2>
    <div id="messages"></div>
    <br>
    <input type="text" id="username" placeholder="Your name" value="User1">
    <input type="text" id="messageInput" placeholder="Type a message...">
    <button onclick="sendMessage()">Send</button>

    <script>
        const ws = new WebSocket('ws://localhost:8765');
        const messagesDiv = document.getElementById('messages');

        ws.onmessage = function(event) {
            const data = JSON.parse(event.data);
            const msgDiv = document.createElement('div');
            msgDiv.className = 'message';
            msgDiv.textContent = `[${data.timestamp}] ${data.user}: ${data.message}`;
            messagesDiv.appendChild(msgDiv);
            messagesDiv.scrollTop = messagesDiv.scrollHeight;
        };

        function sendMessage() {
            const username = document.getElementById('username').value;
            const message = document.getElementById('messageInput').value;

            ws.send(JSON.stringify({ user: username, message: message }));
            document.getElementById('messageInput').value = '';
        }

        document.getElementById('messageInput').addEventListener('keypress', function(e) {
            if (e.key === 'Enter') sendMessage();
        });
    </script>
</body>
</html>

Adding Features

User Join/Leave Notifications

async def handle_client(websocket, path):
    # Send welcome message
    await websocket.send(json.dumps({
        "user": "System",
        "message": "Welcome to the chat!",
        "timestamp": datetime.now().strftime("%H:%M:%S")
    }))

    # Notify others
    connected_clients.add(websocket)
    join_message = json.dumps({
        "user": "System",
        "message": "A new user joined the chat",
        "timestamp": datetime.now().strftime("%H:%M:%S")
    })
    await asyncio.gather(
        *[client.send(join_message) for client in connected_clients if client != websocket]
    )

Message History

message_history = []

async def handle_client(websocket, path):
    # Send last 50 messages to new client
    for msg in message_history[-50:]:
        await websocket.send(msg)

Deploying to Production

Railway.app (free tier): Deploy your WebSocket server
Nginx: Proxy WebSocket connections
SSL: Use wss:// for secure connections

location /ws {
    proxy_pass http://localhost:8765;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
}

Real-World Applications

This same architecture powers:

Live customer support chat
Collaborative document editing
Real-time dashboards
Multiplayer game state sync
Live auction bidding systems

Need a Custom Real-Time Application?

Building a chat system, live dashboard, or real-time notification system for your business?

Custom Bot Development - WhatsApp/Telegram bots from $20
REST API Development - WebSocket APIs from $20
AI Chatbot Integration - AI-powered chat from $20

What real-time features are you building? Share in the comments!

ChatGPT API vs Gemini API vs Claude API: Which Is Best for Your Project in 2025?

Joey Umanito — Fri, 27 Feb 2026 02:33:16 +0000

Choosing the right AI API can make or break your project. I have tested all three major options extensively. Here is my honest comparison to help you decide.

Quick Comparison Table

Feature	ChatGPT (OpenAI)	Gemini (Google)	Claude (Anthropic)
Free Tier	Limited	Yes (generous)	Yes (limited)
Best For	General tasks	Long context	Safety-critical
Context Window	128K tokens	1M tokens	200K tokens
Pricing	$0.002/1K tokens	Free to $0.07/1K	$0.003/1K tokens
Code Generation	Excellent	Very Good	Excellent
Speed	Fast	Very Fast	Moderate

OpenAI ChatGPT API

The most popular choice. Massive ecosystem and community support.

from openai import OpenAI

client = OpenAI(api_key="YOUR_KEY")

def ask_chatgpt(question):
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # Most cost-effective
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": question}
        ]
    )
    return response.choices[0].message.content

answer = ask_chatgpt("Explain REST APIs in simple terms")
print(answer)

Best for:

Production applications needing reliability
Projects with complex reasoning requirements
When you need the largest plugin ecosystem

Pricing: gpt-4o-mini is $0.15/1M input tokens (very affordable)

Google Gemini API

Google's answer to ChatGPT. The free tier is surprisingly generous.

import google.generativeai as genai

genai.configure(api_key="YOUR_KEY")
model = genai.GenerativeModel("gemini-1.5-flash")

def ask_gemini(question):
    response = model.generate_content(question)
    return response.text

def analyze_long_document(document):
    prompt = f"Summarize the key points from this document:\n\n{document}"
    response = model.generate_content(prompt)
    return response.text

answer = ask_gemini("What are the best Python frameworks in 2025?")
print(answer)

Best for:

Startups and side projects (generous free tier)
Processing very long documents (1M token context)
Google ecosystem integration
Multimodal tasks (text + images + video)

Free tier: 15 requests/minute, 1500/day — perfect for development

Anthropic Claude API

The safety-focused alternative. Excellent for content moderation and sensitive applications.

import anthropic

client = anthropic.Anthropic(api_key="YOUR_KEY")

def ask_claude(question):
    message = client.messages.create(
        model="claude-3-haiku-20240307",  # Most affordable
        max_tokens=1024,
        messages=[{"role": "user", "content": question}]
    )
    return message.content[0].text

def moderate_content(text):
    prompt = f"Is this content appropriate for a family audience? Reply YES or NO then explain:\n\n{text}"
    return ask_claude(prompt)

result = ask_claude("Write a Python function to sort a list")
print(result)

Best for:

Content moderation systems
Applications requiring ethical AI behavior
Long-form writing and analysis
Customer service where tone matters

My Recommendation by Use Case

Building a chatbot? → Use OpenAI GPT-4o-mini
Analyzing long documents? → Use Gemini 1.5 Pro
Content moderation? → Use Claude Haiku
Side project / MVP? → Start with Gemini (free tier)
Production at scale? → OpenAI or Claude based on use case

Cost Optimization Tips

import tiktoken

def estimate_cost(text, model="gpt-4o-mini"):
    encoding = tiktoken.encoding_for_model(model)
    tokens = len(encoding.encode(text))

    # Pricing per 1M tokens
    prices = {
        "gpt-4o-mini": 0.15,
        "gpt-4o": 2.50,
        "gemini-1.5-flash": 0.075,
        "claude-3-haiku": 0.25
    }

    price_per_token = prices.get(model, 0.15) / 1_000_000
    cost = tokens * price_per_token

    return f"Tokens: {tokens}, Estimated cost: ${cost:.6f}"

print(estimate_cost("Hello, how are you today?"))

Building a Multi-AI Application

Smart applications use the right model for each task:

class SmartAIRouter:
    def __init__(self):
        self.openai_client = OpenAI(api_key="OPENAI_KEY")
        self.gemini_model = genai.GenerativeModel("gemini-1.5-flash")

    def route_request(self, task_type, content):
        if task_type == "code":
            return self.use_openai(content)
        elif task_type == "long_document":
            return self.use_gemini(content)
        elif task_type == "moderation":
            return self.use_claude(content)
        else:
            return self.use_gemini(content)  # Default (free)

    def use_openai(self, prompt):
        response = self.openai_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content

    def use_gemini(self, prompt):
        response = self.gemini_model.generate_content(prompt)
        return response.text

Need a Custom AI Integration?

Want to integrate AI into your existing application but not sure which API to use or how to set it up? I can help:

AI Chatbot Development - Custom AI chatbots from $20
REST API Development - AI-powered APIs from $20
AI Content Generation Setup - Automated content systems from $20

Which AI API are you using in your projects? Let me know in the comments!

How I Built 3 Passive Income Streams as a Developer (With No Upfront Cost)

Joey Umanito — Fri, 27 Feb 2026 02:32:32 +0000

Six months ago, I had one income source: my day job. Today, I have three additional passive income streams that require almost zero maintenance. Here is exactly what I built and how you can do the same.

Stream 1: APIs on RapidAPI Marketplace

RapidAPI is like the App Store for APIs. You build an API once, list it, and earn money every time someone makes a call.

What I built:

Text Summarizer API
Email Validator API
AI Content Generator API

How to get started:

from fastapi import FastAPI

app = FastAPI(title="My Monetized API")

@app.post("/summarize")
def summarize_text(text: str):
    # Your API logic here
    words = text.split()
    summary = " ".join(words[:50]) + "..."
    return {"summary": summary, "word_count": len(words)}

Host on Railway.app (free tier) and list on RapidAPI. Set pricing at $0.001 per call.

Potential earnings: $50-500/month depending on traffic

Browse my APIs: https://rapidapi.com/joeyumanito

Stream 2: Fiverr Gigs for Specialized Skills

Instead of competing on generic tasks, I created gigs for very specific technical skills:

AI Chatbot Development
REST API Development
WhatsApp and Telegram Bot Development
AI Content Generation Setup

The key insight: specific beats general every time. "I will build you an AI chatbot" gets ignored. "I will integrate GPT-4 with your existing CRM system" gets orders.

My gig structure for maximum conversion:

Title: Specific outcome + timeframe
Description: Problem, solution, deliverables, FAQ
Packages: Basic $20 (simple), Standard $50 (complete), Premium $100 (enterprise)
Gig images: Show the final product, not your process

See my gigs: https://fiverr.com/joeyumanito

Stream 3: Technical Content on Dev.to

Every article I publish here contains links to my APIs and Fiverr gigs. When developers search for tutorials, they find my articles, try my free APIs, and sometimes hire me for custom work.

The content marketing flywheel:

Write tutorial about a topic I know
Include links to relevant paid services
Article ranks on Google
Readers discover my services
Some become paying customers

My content strategy:

Write tutorials that solve real problems
Target keywords developers search for
Include working code examples
End with a soft pitch for paid services

The Numbers (Honest)

I will be transparent: I am in early stages. Current revenue is minimal while I build traffic. But the foundation is solid:

8 articles published (this month)
3 APIs live on RapidAPI
4 Fiverr gigs active
Growing organic traffic from search

The key is consistency. Most developers give up after 2-3 months. Those who stick around for 6-12 months see real results.

How You Can Start Today

Day 1-7: Build one simple API and list it on RapidAPI
Week 2: Create 2-3 Fiverr gigs for your skills
Week 3-4: Write 5 technical articles on Dev.to
Month 2+: Repeat and optimize what works

Total cost: $0 (everything I mentioned has a free tier)

Resources

RapidAPI: https://rapidapi.com (list your APIs for free)
Fiverr: https://fiverr.com (create gigs for free)
Dev.to: https://dev.to (publish content for free)
Railway.app: https://railway.app (host your APIs for free)

Have questions about building passive income as a developer? Ask in the comments!

Python Automation: 5 Tasks You Should Automate Right Now

Joey Umanito — Thu, 26 Feb 2026 02:51:36 +0000

Stop doing repetitive tasks manually. Python makes it easy to automate your most time-consuming workflows. Here are 5 tasks you can automate today, with complete code examples.

1. Automated Email Reports

Send daily/weekly reports automatically:

import smtplib
import schedule
import time
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from datetime import datetime

def send_report(recipient, subject, body):
    sender = "your_email@gmail.com"
    password = "your_app_password"

    msg = MIMEMultipart()
    msg["From"] = sender
    msg["To"] = recipient
    msg["Subject"] = subject
    msg.attach(MIMEText(body, "html"))

    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
        server.login(sender, password)
        server.send_message(msg)

    print(f"Report sent to {recipient}")

def generate_daily_report():
    today = datetime.now().strftime("%Y-%m-%d")
    body = f"""
    <h2>Daily Report - {today}</h2>
    <p>Automated report generated by Python.</p>
    <ul>
        <li>Task 1: Complete</li>
        <li>Task 2: In Progress</li>
    </ul>
    """
    send_report("boss@company.com", f"Daily Report {today}", body)

schedule.every().day.at("08:00").do(generate_daily_report)

while True:
    schedule.run_pending()
    time.sleep(60)

2. Automated File Organization

Sort downloads folder automatically:

import os
import shutil
from pathlib import Path
import schedule

DOWNLOADS = Path.home() / "Downloads"

FILE_CATEGORIES = {
    "Images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg"],
    "Videos": [".mp4", ".mkv", ".avi", ".mov", ".wmv"],
    "Documents": [".pdf", ".doc", ".docx", ".txt", ".xlsx", ".pptx"],
    "Audio": [".mp3", ".wav", ".flac", ".aac"],
    "Code": [".py", ".js", ".html", ".css", ".json", ".xml"],
    "Archives": [".zip", ".rar", ".tar", ".gz", ".7z"]
}

def organize_downloads():
    for file_path in DOWNLOADS.iterdir():
        if file_path.is_file():
            extension = file_path.suffix.lower()

            category = "Other"
            for cat, extensions in FILE_CATEGORIES.items():
                if extension in extensions:
                    category = cat
                    break

            target_folder = DOWNLOADS / category
            target_folder.mkdir(exist_ok=True)

            shutil.move(str(file_path), str(target_folder / file_path.name))
            print(f"Moved {file_path.name} to {category}/")

schedule.every().hour.do(organize_downloads)

while True:
    schedule.run_pending()
    time.sleep(60)

3. Web Scraping for Price Tracking

Track product prices and get alerts:

import requests
from bs4 import BeautifulSoup
import smtplib
import schedule

def check_price(url, target_price, product_name):
    headers = {"User-Agent": "Mozilla/5.0"}
    response = requests.get(url, headers=headers)
    soup = BeautifulSoup(response.content, "html.parser")

    # Adjust selector for your target website
    price_element = soup.find("span", {"class": "price"})
    if price_element:
        price_text = price_element.get_text().replace("$", "").replace(",", "").strip()
        current_price = float(price_text)

        print(f"{product_name}: Current ${current_price}, Target ${target_price}")

        if current_price <= target_price:
            send_alert(product_name, current_price, url)

def send_alert(product, price, url):
    print(f"PRICE DROP ALERT: {product} is now ${price}! Buy at: {url}")
    # Add email notification here

# Track multiple products
products = [
    {"url": "https://example.com/product1", "target": 50, "name": "Laptop Stand"},
]

for product in products:
    schedule.every(6).hours.do(
        check_price, product["url"], product["target"], product["name"]
    )

while True:
    schedule.run_pending()

4. Social Media Auto-Posting

Schedule posts across platforms:

import tweepy
import schedule
import time
from datetime import datetime

def create_twitter_client():
    auth = tweepy.OAuthHandler("API_KEY", "API_SECRET")
    auth.set_access_token("ACCESS_TOKEN", "ACCESS_SECRET")
    return tweepy.API(auth)

CONTENT_CALENDAR = [
    {"time": "09:00", "text": "Good morning! Here is your Python tip of the day: Use list comprehensions for cleaner code! #Python #Programming"},
    {"time": "13:00", "text": "Afternoon reminder: Take breaks from coding every 45 minutes. Your brain needs rest to work better! #DevLife"},
    {"time": "18:00", "text": "Evening reading recommendation: Check out the Python documentation for new features in 3.12! #Python"},
]

twitter = create_twitter_client()

for post in CONTENT_CALENDAR:
    schedule.every().day.at(post["time"]).do(
        lambda text=post["text"]: twitter.update_status(text)
    )

while True:
    schedule.run_pending()
    time.sleep(60)

5. Database Backup Automation

Never lose your data:

import subprocess
import os
import schedule
from datetime import datetime

BACKUP_DIR = "/backups"
DB_NAME = "myapp_db"
DB_USER = "postgres"

def backup_database():
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_file = f"{BACKUP_DIR}/{DB_NAME}_{timestamp}.sql"

    os.makedirs(BACKUP_DIR, exist_ok=True)

    command = f"pg_dump -U {DB_USER} {DB_NAME} > {backup_file}"
    result = subprocess.run(command, shell=True, capture_output=True)

    if result.returncode == 0:
        print(f"Backup successful: {backup_file}")
        cleanup_old_backups()
    else:
        print(f"Backup failed: {result.stderr.decode()}")

def cleanup_old_backups():
    backups = sorted(Path(BACKUP_DIR).glob("*.sql"))
    if len(backups) > 7:
        for old_backup in backups[:-7]:
            old_backup.unlink()
            print(f"Deleted old backup: {old_backup}")

schedule.every().day.at("02:00").do(backup_database)

while True:
    schedule.run_pending()
    time.sleep(3600)

Running Your Automation Scripts

Keep scripts running with PM2:

npm install -g pm2
pm2 start automation.py --interpreter python3
pm2 save
pm2 startup

Want Custom Automation Built For You?

Need a specific workflow automated for your business? Whether it is:

Report generation and distribution
Data processing pipelines
Social media management
File organization systems

I can build it for you professionally:

AI Content Generation and Automation - from $20
Custom Bot Development - from $20

What task do you want to automate first? Share in the comments!

10 Must-Have APIs for Every Developer (With Python Code Examples)

Joey Umanito — Thu, 26 Feb 2026 02:50:21 +0000

Every developer needs a set of go-to APIs that make building faster and easier. Here are 10 must-have APIs that I use in almost every project, with code examples for each.

1. OpenWeatherMap API (Free)

Get real-time weather data for any location.

import requests

def get_weather(city):
    url = f"https://api.openweathermap.org/data/2.5/weather"
    params = {"q": city, "appid": "YOUR_KEY", "units": "metric"}
    response = requests.get(url, params=params)
    data = response.json()
    return f"{city}: {data['main']['temp']}C, {data['weather'][0]['description']}"

print(get_weather("Kuala Lumpur"))

Free tier: 60 calls/minute, 1000 calls/day

2. News API (Free Tier)

Get latest news from thousands of sources.

import requests

def get_news(topic):
    url = "https://newsapi.org/v2/everything"
    params = {"q": topic, "apiKey": "YOUR_KEY", "pageSize": 5}
    response = requests.get(url, params=params)
    articles = response.json()["articles"]
    return [{"title": a["title"], "url": a["url"]} for a in articles]

news = get_news("artificial intelligence")
for item in news:
    print(item["title"])

Free tier: 100 requests/day

3. ExchangeRates API (Free)

Real-time currency exchange rates.

import requests

def convert_currency(amount, from_currency, to_currency):
    url = f"https://api.exchangerate-api.com/v4/latest/{from_currency}"
    response = requests.get(url)
    rates = response.json()["rates"]
    return amount * rates[to_currency]

usd_to_myr = convert_currency(100, "USD", "MYR")
print(f"100 USD = {usd_to_myr:.2f} MYR")

Free tier: 1500 requests/month

4. IP Geolocation API (Free)

Get location data from an IP address.

import requests

def get_location(ip):
    response = requests.get(f"https://ipapi.co/{ip}/json/")
    data = response.json()
    return f"{data['city']}, {data['country_name']}"

location = get_location("8.8.8.8")
print(f"IP Location: {location}")

Free tier: 1000 requests/day

5. QR Code Generator API (Free)

Generate QR codes for any text or URL.

import requests

def generate_qr(data, filename="qr.png"):
    url = f"https://api.qrserver.com/v1/create-qr-code/?size=200x200&data={data}"
    response = requests.get(url)
    with open(filename, "wb") as f:
        f.write(response.content)
    return filename

qr_file = generate_qr("https://fiverr.com/joeyumanito")
print(f"QR code saved: {qr_file}")

Completely free, no API key needed!

6. Random User Generator (Free)

Generate fake user data for testing.

import requests

def generate_users(count=5):
    response = requests.get(f"https://randomuser.me/api/?results={count}")
    users = response.json()["results"]
    return [{
        "name": f"{u['name']['first']} {u['name']['last']}",
        "email": u["email"],
        "country": u["location"]["country"]
    } for u in users]

test_users = generate_users(3)
for user in test_users:
    print(user)

Free, no API key needed!

7. Text Summarizer API (RapidAPI - Free Tier)

Summarize long texts with AI.

import requests

def summarize(text):
    url = "https://ai-text-summarizer5.p.rapidapi.com/summarize"
    headers = {
        "X-RapidAPI-Key": "YOUR_KEY",
        "X-RapidAPI-Host": "ai-text-summarizer5.p.rapidapi.com"
    }
    response = requests.post(url, json={"text": text}, headers=headers)
    return response.json().get("summary", "")

summary = summarize("Your long article text here...")
print(summary)

Try it free: https://rapidapi.com/joeyumanito/api/ai-text-summarizer5

8. Email Validator API (RapidAPI - Free Tier)

Validate email addresses before sending.

import requests

def validate_email(email):
    url = "https://email-validator-pro2.p.rapidapi.com/validate"
    headers = {
        "X-RapidAPI-Key": "YOUR_KEY",
        "X-RapidAPI-Host": "email-validator-pro2.p.rapidapi.com"
    }
    response = requests.get(url, params={"email": email}, headers=headers)
    return response.json()

result = validate_email("test@example.com")
print("Valid:", result.get("is_valid"))

Try it free: https://rapidapi.com/joeyumanito/api/email-validator-pro2

9. GitHub API (Free)

Access any public GitHub data.

import requests

def get_repo_stats(owner, repo):
    url = f"https://api.github.com/repos/{owner}/{repo}"
    response = requests.get(url)
    data = response.json()
    return {
        "stars": data["stargazers_count"],
        "forks": data["forks_count"],
        "language": data["language"]
    }

stats = get_repo_stats("python", "cpython")
print(stats)

Free: 60 requests/hour (5000 with auth)

10. Dictionary API (Free)

Get word definitions, synonyms, and more.

import requests

def define_word(word):
    response = requests.get(f"https://api.dictionaryapi.dev/api/v2/entries/en/{word}")
    data = response.json()[0]
    definition = data["meanings"][0]["definitions"][0]["definition"]
    return f"{word}: {definition}"

print(define_word("algorithm"))

Completely free, no API key!

Bonus: Combine Multiple APIs

Here is a practical example combining weather and news:

def daily_briefing(city, topic):
    weather = get_weather(city)
    news = get_news(topic)[:3]

    briefing = f"Good morning!\n\nWeather: {weather}\n\nTop {topic} news:\n"
    for i, item in enumerate(news, 1):
        briefing += f"{i}. {item['title']}\n"

    return briefing

print(daily_briefing("Kuala Lumpur", "technology"))

Need Custom API Integration?

Need a specific API integrated into your project? I can help with:

REST API development and integration
Bot development for Telegram and WhatsApp
AI-powered automation systems

Check out my Fiverr gigs:

Which API is your favorite? Let me know in the comments!

Build an AI-Powered Telegram Bot with Python (Complete Guide)

Joey Umanito — Thu, 26 Feb 2026 02:42:24 +0000

Telegram bots are powerful tools for automation, customer service, and productivity. In this tutorial, I will show you how to build a feature-rich Telegram bot with Python in just 15 minutes.

Why Telegram Bots?

Telegram bots are perfect for:

Customer support automation
Daily notifications and reminders
Data collection and surveys
File sharing and processing
E-commerce order tracking

Step 1: Create Your Bot

First, create a bot with BotFather on Telegram:

Open Telegram and search for @BotFather
Send /newbot
Choose a name and username for your bot
Copy your bot token (keep it secret!)

Step 2: Install python-telegram-bot

pip install python-telegram-bot

Step 3: Build a Basic Bot

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

TOKEN = "YOUR_BOT_TOKEN_HERE"

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "Hello! I am your AI assistant bot.\n\n"
        "Commands:\n"
        "/start - Show this message\n"
        "/help - Get help\n"
        "/weather - Get weather info\n"
        "Or just send me any message!"
    )

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("Send me any text and I will respond intelligently!")

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_text = update.message.text
    user_name = update.effective_user.first_name

    response = f"Hi {user_name}! You said: {user_text}"
    await update.message.reply_text(response)

def main():
    app = Application.builder().token(TOKEN).build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("help", help_command))
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))

    print("Bot is running...")
    app.run_polling()

if __name__ == "__main__":
    main()

Step 4: Add AI Responses with OpenAI

Make your bot intelligent:

import openai

openai_client = openai.OpenAI(api_key="YOUR_OPENAI_KEY")

async def ai_response(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_message = update.message.text

    await update.message.reply_text("Thinking...")

    response = openai_client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "You are a helpful assistant bot on Telegram."},
            {"role": "user", "content": user_message}
        ]
    )

    ai_reply = response.choices[0].message.content
    await update.message.reply_text(ai_reply)

# Replace the echo handler with AI response handler
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, ai_response))

Step 5: Add Inline Buttons

Create interactive menus:

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton("Option 1", callback_data="opt1"),
         InlineKeyboardButton("Option 2", callback_data="opt2")],
        [InlineKeyboardButton("Contact Support", url="https://t.me/yoursupport")]
    ]

    reply_markup = InlineKeyboardMarkup(keyboard)
    await update.message.reply_text("Choose an option:", reply_markup=reply_markup)

Step 6: Deploy to a Server

Use a Dockerfile for easy deployment:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY bot.py .
CMD ["python", "bot.py"]

Deploy free on Railway.app or Render.com!

Common Use Cases for Businesses

E-commerce: Order status updates, tracking notifications
Customer Support: Auto-answer FAQs, ticket creation
Content: Daily news digests, blog post notifications
HR: Leave requests, attendance tracking
Restaurants: Menu ordering, reservations

Want a Custom Telegram Bot Built for You?

Building a production-ready Telegram bot with AI features, database integration, and business logic takes expertise. Instead of spending days learning, let me build it for you:

WhatsApp and Telegram Bot Development starting at $20
Fast delivery, clean code, full documentation included

Got questions about Telegram bot development? Drop a comment below!

How to Automate Content Creation with AI (Python Tutorial)

Joey Umanito — Thu, 26 Feb 2026 02:41:53 +0000

Content creation is time-consuming. What if you could automate 80% of it with AI? In this guide, I will show you how to build an AI content generation system that writes blog posts, social media captions, and product descriptions automatically.

What We Build

A Python script that:

Takes a topic as input
Uses AI to generate full blog posts
Creates social media captions automatically
Saves content to files for review

Step 1: Set Up Your Environment

Install required packages:

pip install openai jinja2 python-dotenv

Create a .env file:

OPENAI_API_KEY=your_api_key_here

Step 2: Create the Content Generator

import openai
import os
from dotenv import load_dotenv

load_dotenv()

client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def generate_blog_post(topic, word_count=500):
    prompt = f"Write a {word_count}-word blog post about: {topic}. Use markdown headers."

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=1500
    )

    return response.choices[0].message.content

def generate_social_caption(content, platform="twitter"):
    prompt = f"Create a {platform} caption with hashtags for this content: {content[:300]}"

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=200
    )

    return response.choices[0].message.content

topic = "The Future of Remote Work in 2025"
blog_post = generate_blog_post(topic)
caption = generate_social_caption(blog_post, "twitter")
print(blog_post)

Step 3: Auto-Publish to Dev.to

import requests

def publish_to_devto(title, content, tags, api_key):
    response = requests.post(
        "https://dev.to/api/articles",
        headers={"api-key": api_key},
        json={"article": {"title": title, "published": True, "body_markdown": content, "tags": tags}}
    )
    return response.json()

result = publish_to_devto(topic, blog_post, ["ai", "productivity"], "YOUR_KEY")
print("Published:", result.get("url"))

Step 4: Schedule Automated Publishing

import schedule
import time
import random

TOPICS = [
    "Python tips for beginners",
    "Best VS Code extensions 2025",
    "How to learn machine learning"
]

def daily_job():
    topic = random.choice(TOPICS)
    content = generate_blog_post(topic)
    publish_to_devto(topic, content, ["python", "webdev"], "YOUR_KEY")

schedule.every().day.at("09:00").do(daily_job)

while True:
    schedule.run_pending()
    time.sleep(3600)

Real Results You Can Expect

With this system running daily:

30 articles per month published automatically
500 to 1000 new readers per month from organic search
5 to 10 hours saved per week on content creation

Want This Set Up For You?

If you want this done professionally without the setup hassle:

AI Content Generation Setup starting at $20
Custom AI Chatbot for your website

Have questions? Drop a comment below!