DEV Community

Alex Spinov
Alex Spinov

Posted on

I Ran an AI Agent Autonomously for 16 Days — Here Is What Actually Works

#programming #ai #productivity #webdev

I have been running an AI agent autonomously for 16 days. It writes articles, optimizes product descriptions, manages GitHub repos, pitches paid publications, and reports back daily via Telegram.

Here is what I learned about building AI agents that actually DO things — not just chat.

The Problem With Most AI Agents

Most AI agent tutorials show you how to make a chatbot that calls a few tools. That is not an agent. That is a chat wrapper.

A real agent:

  • Decides what to do next without being asked
  • Chains 50+ actions in a single session
  • Recovers from failures automatically
  • Manages its own context (saves state, clears memory, continues)
  • Produces measurable output (articles published, code deployed, emails sent)

My Setup 

Claude Code (CLI) + MCP Servers + Bash + APIs
Enter fullscreen mode Exit fullscreen mode

That is it. No LangChain. No CrewAI. No framework. Just:

  1. Claude Code as the reasoning engine
  2. MCP servers for Playwright (browser), Telegram (reporting), GitHub
  3. Direct API calls for Dev.to, Apify, GitHub REST API
  4. Bash for everything else

The agent runs in a terminal. It reads its CLAUDE.md file (instructions), checks its context-snapshot.md (memory), and starts working.

The Architecture That Works 

CLAUDE.md (permanent instructions)
  ├── Mission & rules
  ├── Platform credentials
  ├── Task queue (infinite loop)
  └── Anti-patterns to avoid

context-snapshot.md (volatile memory)
  ├── What was done last session
  ├── What to do next
  └── Current metrics

journal.md (persistent log)
  ├── Actions taken
  ├── Results
  └── Decisions made
Enter fullscreen mode Exit fullscreen mode

Key insight: The agent does not need a database. Three markdown files give it everything: instructions (CLAUDE.md), short-term memory (context-snapshot.md), and long-term memory (journal.md).

What the Agent Actually Does (Daily)

  1. Reads its state files
  2. Checks metrics (Dev.to views, GitHub stars, Apify runs)
  3. Publishes 2-3 articles via Dev.to API
  4. Updates product descriptions on Apify Store
  5. Cross-links content (articles reference each other)
  6. Optimizes GitHub READMEs
  7. Sends a daily Telegram report
  8. Saves state and continues

In 16 days, it has:

  • Published 650+ technical articles
  • Updated 78 product descriptions
  • Cross-linked 231 articles
  • Managed 300+ GitHub repositories
  • Sent 16 daily reports

The 3 Things That Make It Work

1. Infinite Task Queue

The agent never runs out of things to do. The CLAUDE.md file contains a prioritized loop:

SELL → OPTIMIZE → CREATE → repeat
Enter fullscreen mode Exit fullscreen mode

SELL actions (pitching paid publications) run first. OPTIMIZE (adding CTAs, improving descriptions) runs second. CREATE (new articles) runs last and is capped at 2 per week.

2. Context Management

LLMs have finite context windows. The agent monitors its usage and when it hits 70%, it:

  1. Saves current state to context-snapshot.md
  2. Clears its context
  3. Reads state files and continues from where it left off

This means it can run indefinitely across multiple sessions.

3. Failure Recovery

Every action has a fallback:

  • Platform blocked by captcha? Skip it, try another.
  • API rate limited? Move to next task.
  • Playwright timeout? Abandon that site.
  • Email blocked? Use direct API instead.

The agent never stops because of a single failure.

What Does NOT Work

  • Captcha/2FA: The agent cannot pass these. Blocked platforms are marked DEAD.
  • OAuth flows: Google OAuth in Playwright is unreliable.
  • Email sending: Without SMTP access, the agent cannot send outreach emails.
  • Real-time interaction: The agent cannot moderate comments or respond to DMs.

The Numbers

Metric Day 1 Day 16
Articles 0 650+
GitHub repos ~265 300+
Apify actors 78 78 (all optimized)
Dev.to views 0 4,000+
Revenue /bin/bash /bin/bash

Yes, revenue is still /bin/bash. The agent is excellent at production but conversion remains the bottleneck. Adding CTAs to every article (100% coverage) and pitching paid publications (8 sent) are the current strategies.

How to Build Your Own

  1. Write a detailed CLAUDE.md with your agent instructions
  2. Include credentials, task queue, and anti-patterns
  3. Create context-snapshot.md for session continuity
  4. Set up MCP servers for tools you need (browser, APIs)
  5. Run Claude Code in terminal and let it work

The code is the CLAUDE.md file. The agent is the LLM. The framework is markdown.

The Bottom Line

You do not need LangChain, CrewAI, or AutoGPT to build a useful AI agent. You need:

  • A clear mission
  • A prioritized task queue
  • State management (3 markdown files)
  • API access to your tools
  • An LLM that can chain actions

The hardest part is not the technology. It is writing good instructions.

Building AI agents or need data extraction? I have built 77+ production scrapers and this autonomous agent system. Email Spinov001@gmail.com for custom solutions.

More: awesome-web-scraping (9 stars, 150+ tools) | 650+ articles on Dev.to

Top comments (0)