DEV Community

Jakub
Jakub

Posted on

How Claude Code Became the Backbone of My Digital Agency

#ai #programming #automation #productivity

I run a digital agency called Inithouse with about 14 live products. All of them are early-stage MVPs chasing product-market fit. And all of them are managed, monitored, and partially built by an AI agent.

Not a chatbot. Not a copilot sitting in my IDE. An actual autonomous agent that wakes up on a schedule, picks up approved tasks, does the work, reports what it did, and goes back to sleep.

Here's how I got there and what I learned along the way.

The Problem: Too Many Products, Too Few Hands

When you're running 14 products simultaneously, the operational overhead gets brutal fast. Each product needs SEO monitoring, analytics checks, content updates, bug fixes, deployment verification, and a dozen other things that eat your day.

I needed something that could handle the repetitive operational work autonomously while I focused on strategy and product decisions.

The Stack: Claude Code + MCP Protocol

The core of the system is Claude Code running as a headless agent. But the real power comes from the MCP (Model Context Protocol) ecosystem.

MCP lets you plug external services into Claude as structured tools. Instead of telling the AI "go check my project management tool," it gets native access to create issues, update statuses, leave comments, and query data. Same for team chat, documentation platforms, email, and browser automation.

The agent connects to:

  • Project management for task tracking and workflow
  • Team communication for status updates and alerts
  • Documentation platforms for knowledge storage
  • Browser automation for interacting with web tools that don't have APIs
  • Analytics platforms via browser for data collection

Each connection is a two-way street. The agent reads data, makes decisions, and writes back results.

What the Agent Actually Does

The agent runs on scheduled intervals. Each run follows the same pattern:

  1. Check for approved tasks (humans approve what gets worked on)
  2. Pick the highest priority item
  3. Read any previous context and comments
  4. Do the work
  5. Document what was done
  6. Move the task forward for human review

The "work" varies. Some examples from the last few weeks:

SEO audits across all 14 products. The agent opens Google Search Console, pulls indexation data, checks sitemaps, identifies missing pages, and creates actionable tasks with specific recommendations. It knows each product's domain, analytics IDs, and current state.

Content drafting and research for marketing materials. The agent compiles data, drafts outlines, and prepares content briefs that I then review and publish myself across different platforms.

Analytics monitoring pulling data from GA4 and Microsoft Clarity, spotting trends, and flagging anomalies. If a product suddenly loses traffic or a key metric drops, it creates an alert.

Deployment verification after changes go live. The agent checks that new pages appear in sitemaps, that analytics tracking fires correctly, and that nothing broke in production.

The Human-in-the-Loop Part

This is the piece most people get wrong when thinking about AI agents. The agent never decides what to work on. That's always a human call.

The workflow has a clear approval gate. Ideas and proposals go into a backlog. A human reviews them and moves approved items to a "ready" state. Only then can the agent pick them up.

After the agent finishes, the work goes through human review before it's considered done. The agent can build, analyze, and publish, but a human always validates the output.

This isn't just a safety measure. It's actually more efficient. The agent handles the 80% of execution that's straightforward, and humans focus on the 20% that requires judgment.

Products the Agent Helps Run

The portfolio includes tools across different niches:

Each product is built with Lovable (React SPAs with Supabase backends), and the agent knows how to interact with each one's specific setup.

5 Things I Learned Building This

1. Persistent memory changes everything.
An agent that forgets between runs is basically useless for operational work. The agent needs to remember what it did last time, what feedback it received, and what the current state of each product is. File-based memory that persists across sessions was the single biggest unlock.

2. Structured task management beats free-form instructions.
Telling an AI "go improve my SEO" produces garbage. Giving it a specific task with a defined scope, acceptance criteria, and links to relevant data produces real results. The more structured the input, the better the output.

3. Browser automation fills the API gap.
Half the tools I use don't have proper APIs. Google Search Console, Google Ads, Microsoft Clarity... they're all web-only. Browser automation through MCP bridges that gap. It's slower and more fragile than API calls, but it works.

4. The approval gate is non-negotiable.
Early on I experimented with letting the agent create its own tasks. Bad idea. It would generate busywork that looked productive but didn't move the needle. The human approval step ensures every task the agent works on actually matters.

5. Error handling needs to be graceful, not perfect.
The agent encounters broken pages, changed UIs, expired sessions, and weird edge cases constantly. Instead of trying to handle every possible error, I built it to recognize when it's stuck, document the problem, and move on. A human can always pick up where it left off.

What's Next

I'm working on making the system self-improving. The idea is to have it analyze its own performance, identify patterns in what works and what doesn't, and propose optimizations. Early results are promising but it's still very much experimental.

If you're thinking about building something similar, start small. Get one workflow automated end-to-end before adding more. And always keep humans in the loop for decisions that matter.

The full Inithouse portfolio is at inithouse.com. Happy to answer questions in the comments.

Top comments (0)