જ➣Back to writings

Building Autonomous Agents How to Automate Daily Logs and Blog Generation

A complete guide to building self-directed agents that autonomously discover, analyze, and publish technical blogs from daily engineering work

Aug 19, 2026·15 min read·Manish Bisht
⋆⊱༻𖥸༺⊰⋆

Building Autonomous Agents: How to Automate Daily Logs and Blog Generation

Introduction

The cost of writing is context switching. Every day, valuable technical work happens across multiple repositories, but documenting it requires leaving your editor, organizing thoughts, and fighting the blank page.

What if blogs could write themselves?

This article walks through building an autonomous agent—a system that discovers interesting technical work, understands what happened, and generates draft articles without human intervention. The result: zero friction between shipping code and publishing stories.

The Problem: Manual Curation is Expensive

Consider your daily workflow:

  1. You push code to 5 repositories
  2. Most commits are routine: refactors, dependency bumps, typo fixes
  3. A few are genuinely interesting: a debugging session, a novel architecture, a performance improvement
  4. Writing about them requires:
    • Stopping what you're doing
    • Reviewing commit history
    • Extracting the narrative
    • Writing from scratch

By the time you finish, you've lost momentum and context. The story is diluted.

The ideal: automatic systems that do step 2–4, leaving you to approve or reject. This is where agents come in.

What is an Autonomous Agent?

An agent is a system that:

  • Perceives: Gathers information (commits, diffs, logs)
  • Decides: Chooses actions based on reasoning (is this blog-worthy?)
  • Acts: Executes tasks (writes markdown, creates files, commits)
  • Repeats: Runs on a schedule without human triggering

The autonomous blog agent does all four. It runs once per day, discovers today's work, decides if there's a story, and generates a draft.

Architecture: The Kyogre Pattern

The name comes from Pokémon—it's a creature that dives deep and discovers hidden things. Here, Kyogre dives into your commit history and surfaces stories.

kyogre/
├─ bin/
│  └─ daily.sh              # Orchestration script
├─ src/
│  ├─ tools/
│  │  ├─ collect_commits.py # GitHub Search API
│  │  └─ collect_diffs.py   # GitHub REST API
│  ├─ prompts/
│  │  └─ analyze.md         # Claude's instructions
│  └─ utils/
│     └─ parser.py          # Output parsing
├─ temp/
│  ├─ commits.md            # Daily commit summary
│  ├─ diffs.md              # Detailed code changes
│  └─ logs/                 # Execution history
└─ drafts/                  # Generated articles
   ├─ debugging-session.md
   └─ refactor-decision.md

The flow:

1. Cron triggers daily.sh (3 AM daily)
   ↓
2. collect_commits.py → temp/commits.md
   (GitHub Search API: author:me date:today)
   ↓
3. collect_diffs.py → temp/diffs.md
   (GitHub REST API: commits → diffs)
   ↓
4. claude --permission-mode acceptEdits
   (Read temp/, decide if blog-worthy, write drafts/)
   ↓
5. git diff checks for new files
   (If drafts/, commit and push)

This is step-by-step execution. Each stage has clear inputs and outputs. No magic. No hallucinations. Just tools chained together.

The Agent Harness Architecture

Building an effective autonomous agent requires six core components, as outlined by LangChain:

1. Durable Storage & State Management

Your agent needs persistent memory across runs:

kyogre/
 ├─ temp/             # Ephemeral (cleared daily)
 │  ├─ commits.md    # Daily commit summary
 │  ├─ diffs.md      # Detailed code changes
 │  └─ logs/             # Execution history

Key insight: Separate ephemeral data (temp/) from outputs (drafts/). This makes debugging easier and prevents agent state from accumulating.

2. Code Execution Capabilities

Your agent needs to run code autonomously:

# Stage 1: Collect data
uv run python tools/collect_commits.py

# Stage 2: Process with Claude
claude --permission-mode acceptEdits -p "analyze and write"

# Stage 3: Publish with git/gh
git push && gh pr create

The key is using --permission-mode acceptEdits so Claude can write files without interactive prompts.

3. Safe Execution Environments

Use virtual environments and permission boundaries:

# Python venv isolation
uv sync

# Bash safety
set -euo pipefail

# Permission checking before publishing
if [ -n "$(git status --porcelain)" ]; then
  echo "ERROR: Uncommitted changes"
  exit 1
fi

4. Learning & Knowledge Systems

Add persistent memory between runs:

# logs/run_20260819.json
{
  "timestamp": "2026-08-19T03:00:00Z",
  "commits_found": 12,
  "drafts_written": 1,
  "draft_path": "drafts/debugging-concurrency.md",
  "reasoning": "Complex concurrency bug fix, worth sharing"
}

This creates a learning trail. Over time, you see patterns: when the agent writes, what it decides is interesting, which articles got published.

5. Tool Integration & API Permissions

Constrain what your agent can do:

# Allowed APIs
- GitHub Search (read-only)
- GitHub REST (read commits/diffs only)
- Claude (read temp/, write drafts/)

# Forbidden
- Delete repositories
- Publish without review
- Modify .git/config

Tight permissions prevent silent failures.

6. Long-Horizon Execution

Orchestrate multi-step workflows with validation:

# 12-step pipeline with checkpoints
1. Collect commits
2. Collect diffs
3. Analyze with Claude
4. Validate draft count (must be 0 or 1)
5. Check portfolio repo state
6. Copy draft
7. Create branch
8. Validate changes
9. Commit
10. Push
11. Create PR
12. Cleanup

Each step validates assumptions before proceeding. This prevents cascading failures.

Implementation: Three-Stage Pipeline

Stage 1: Data Collection (Python Tools)

File: src/kyogre/tools/collect_commits.py

import requests
from datetime import datetime
from pathlib import Path

GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
headers = {'Authorization': f'token {GITHUB_TOKEN}'}

# Query today's commits
today = datetime.now().strftime('%Y-%m-%d')
query = f'author:manishbisht committer-date:{today}'
response = requests.get(
    'https://api.github.com/search/commits',
    params={'q': query},
    headers=headers
)

commits = response.json()['items']

# Write structured output
output = Path('temp/commits.md')
output.write_text(
    '# Commits from ' + today + '\n\n' +
    '\n'.join(f'- [{c["commit"]["message"]}]({c["html_url"]})' for c in commits)
)

The output is machine-readable markdown:

# Commits from 2026-08-19

- [Fix concurrency bug in auth flow](https://github.com/...)
- [Refactor database schema](https://github.com/...)
- [Add monitoring dashboard](https://github.com/...)

Why Search API? It's O(1) in practice. Iterating repos to find commits would be O(n repos) and slow.

Stage 2: Fetch Diffs (Python Tools)

File: src/kyogre/tools/collect_diffs.py

for commit in commits:
    sha = commit['sha']
    response = requests.get(
        f"https://api.github.com/repos/{owner}/{repo}/commits/{sha}",
        headers=headers
    )
    patch = response.json()['files']
    # Write to temp/diffs.md

Output:

# Diff for: Fix concurrency bug in auth flow

## File: src/auth/session.ts

@@ -42,8 +42,12 @@
async function validateToken(token: string) {
- const user = await db.users.findOne({ token })
+ const user = await db.users.findOne({ token }).lock()
+ if (!user) return null
- return user.id
+ return { id: user.id, locked: true }
}

Stage 3: AI Analysis (Claude Agent)

File: bin/daily.sh

#!/bin/bash
set -euo pipefail

claude --permission-mode acceptEdits -p "
Read temp/commits.md and temp/diffs.md

Determine if there's a genuinely valuable technical story:
- Ignore: typo fixes, dependency bumps, README changes
- Prefer: debugging, architecture, performance, lessons

If yes:
  Create drafts/{slug}.md with full article:
  - Context: What problem existed?
  - Work: What did you do?
  - Lessons: What did you learn?

If no:
  Report: 'No blog-worthy stories today'
"

This is the heart of the system. Claude reads raw data and decides what's interesting.

Why This Approach Works

API Efficiency Matters

The Search API returns O(1). Iteration would be O(n repos) per day. At 100 repos, that's 100 API calls just to find commits. Search does it in 1.

AI is Better at Judgment Than Rules

Keyword matching fails:

  • "fix typo" matches "fix" but is noise
  • "refactor auth flow" has no keywords but is interesting
  • Rules need constant tuning

AI filtering is flexible:

  • Tell Claude the criteria (architectural interest, difficulty, lessons)
  • The prompt is maintainable
  • If criteria change, update the prompt, not code

Permission Modes Enable Hands-Free Automation

Without --permission-mode acceptEdits, Claude pauses for confirmation:

  • User has to read output
  • User clicks "approve"
  • Script waits for manual action
  • Automation breaks

With it:

  • Claude writes files directly
  • Script continues uninterrupted
  • Enables hands-free execution

Temporary Files are Debugging Gold

temp/
├─ commits.md    # Human readable
├─ diffs.md      # Human readable
└─ logs/         # Structured JSON

If something fails, you can inspect intermediate results. No black boxes.

The Harness is the Hard Part

Building agents is 10% model, 90% plumbing. The model is smart, but infrastructure determines if it's practical:

  • Error handling at each stage
  • Validation checkpoints
  • Permission boundaries
  • Rollback strategies
  • Logging and observability

Get the harness right, and any model works. Skimp on it, and even brilliant models fail silently.

Integration with Your Workflow

Add to crontab:

# 3 AM every day
0 3 * * * /home/user/kyogre/bin/daily.sh >> /home/user/kyogre/logs/cron.log 2>&1

Or use GitHub Actions:

name: Daily Blog Agent
on:
  schedule:
    - cron: '0 3 * * *'

jobs:
  kyogre:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: ./bin/daily.sh
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Result: Every morning, drafts appear in your PR. Review, merge, ship.

Lessons Learned

  1. API efficiency saves tokens: Search beats iteration. Pre-filtering beats sending everything.

  2. AI is better at judgment than rules: Let Claude decide blog-worthiness, not keyword matching.

  3. Permission modes enable hands-free automation: --permission-mode acceptEdits removes interactive bottlenecks.

  4. Validate at every step: Checkpoints prevent silent failures.

  5. Temporary files are debugging gold: Human-readable intermediate data makes issues obvious.

  6. The harness is the hard part: The model is smart, but infrastructure determines if it's practical.

Building Your Own Agent

You don't need permission from LLMs to build agents. You need:

  1. Clear inputs (commits, diffs)
  2. Clear outputs (draft files)
  3. Permission to write (--permission-mode acceptEdits)
  4. Safe boundaries (read-only APIs, temp files)
  5. Observability (logs, intermediate files)

Then iterate. Is it writing junk? Refine the prompt. Is it missing stories? Ask Claude to be more aggressive. Is it breaking things? Add validation.

Start simple: build a system that writes one draft per day, nothing more. Ship it. Make it useful. Improve through logs.

Perfection is the enemy of shipped. Build the minimum harness that works, then iterate.

Next: Multi-Platform Agents

The kyogre pattern extends beyond blogging:

  • Social media agents: Convert blogs to tweets, LinkedIn posts
  • Documentation agents: Auto-generate API docs from code
  • Code review agents: Flag suspicious patterns in PRs
  • Performance agents: Detect regressions and alert
  • Learning agents: Summarize knowledge from daily activity

The harness remains the same. Only the prompt and actions change.

Start building your agent today. The only permission you need is the ability to write files and call APIs. Everything else is scaffolding you control.

⁀જ➣What comes next

Page 6/9

Until then⁀જ➣