My AI Agent System: How I Automated My Indie Dev Business

I have a confession: most of the things running in my business aren’t done by me anymore.

Deploys. SEO. Reddit posts. ASO screenshots. Code reviews. Repo syncs. All of it runs autonomously, multiple times a day, without me touching anything.

No, I didn’t hire anyone. I built a system of AI agents. And today I’ll show you how it’s set up.

The core idea

The concept is simple: an orchestrator that coordinates multiple specialized agents. Each agent has its role, its skills, its automations. The orchestrator makes them work together, passes the right context, and handles communications (Telegram, Discord, etc.).

Basically an invisible team lead who manages agents instead of humans.

If you’ve tried running one big prompt that does everything, you know it doesn’t scale. Once context gets too large, quality falls apart. The multi-agent approach fixes this: each agent has a clear scope, a small context window, and actually knows its domain.

My actual setup

I run four main agents. Each has a name, a role, and well-defined skills.

The dev agent

This one writes code. It spawns sub-agents to implement features, fix bugs, review code. It works directly on repos, creates PRs, and follows my BMAD workflow. When I say “I want this feature on Muse Otter,” it breaks it down into stories and executes.

The marketing agent

Handles everything related to organic acquisition:

• Reddit: karma-building posts in the morning, subtle promo posts in the afternoon, comment engagement
• SEO: technical audits, page optimization, articles
• ASO: App Store metadata, keyword research, multilingual screenshots

It has its own “writing fingerprint” for each platform. Doesn’t sound like a bot. Sounds like me, just better structured.

The ops agent

The real Swiss army knife:

• Deploys: Firebase hosting, functions, landing pages
• Repo sync: daily pulls, change detection, README updates
• Architecture review: weekly code health audits
• Health checks: dependency analysis, npm audit, flutter analyze

Least glamorous agent, most critical one. Without it, everything else quietly falls apart.

The QA agent

Runs non-regression testing in the browser on deployed web apps. Catches regressions, visual bugs, broken flows. When it finds something, it escalates to the Dev agent who fixes it, then QA revalidates. Closed loop.

What it actually automates

To give you an idea of what runs without me on a daily basis:

Every day:

• 2 Reddit posts (1 casual + 1 subtle promo)
• Sync across all repos with change detection
• Morning briefing with strategic decisions to make

Every week:

• Code health audit (analyze, dependencies, security)
• Architecture review
• ASO metadata optimization
• Marketing context sync (features, positioning, metrics)

On demand:

• Full Firebase deploy
• Automatic multilingual ASO screenshots (see below)
• Full non-regression testing in browser
• Dev sprint across N stories
• Complete SEO audit of a site

What surprised me the most is the mental bandwidth that comes back. Before, I was carrying all these tasks in my head. Now they exist in a system that runs them for me.

Deep dive: fully aI-generated ASO screenshots

A good example of what “automatic” actually means here: App Store screenshots.

All I provided was a product brief, marketing context, positioning, key features. No mockups, no slides, no screenshots. Just text.

The agent handles everything else:

1. It opens the deployed web app in a headless browser, navigates through screens, and takes the captures itself
2. It fixes the aspect ratios (Flutter web doesn’t render at iPhone ratios, padding is needed)
3. It generates the final mockups using an open-source Next.js web app (ParthJadhav/app-store-screenshots), iPhone frame, marketing headline, brand colors extracted from the source code
4. It exports to all 4 required Apple sizes and copies them into fastlane

I didn’t touch a single step. The AI took the screenshots, built the slides, picked the headlines, and delivered the final output. I just approved.

Why it’s easy to set up

I can already hear the question: “Ok but this must be a nightmare to configure?”

Actually no. And that’s what convinced me.

Each agent is defined in YAML. Its name, its model, its skills, its crons. It’s declarative. You don’t code a framework, you describe what you want.

Skills are reusable. A skill is a Markdown file that describes a capability. How to deploy on Firebase. How to post on Reddit. How to audit SEO. Write it once, any agent can use it.

Crons are just classic scheduling. 0 9 * * * for the morning Reddit post. 0 8 * * 1 for the weekly audit. Nothing new.

Context is shared via workspace files. Each app has its product sheet, its marketing brief, its current state. Agents read these files and act accordingly. No database, no custom API. Markdown files in a folder.

The result: adding a new automation usually means adding a skill and a cron. No need to touch anything else.

What changed compared to before

Before this setup, my week looked like this:

• Monday: “I should really do those ASO screenshots for Muse Otter”
• Tuesday: procrastinate because it’s tedious
• Wednesday: “I need to post on Reddit”
• Thursday: forget to deploy the landing page
• Friday: run flutter analyze and discover 12 warnings I could have fixed Monday

Now:

• ASO screenshots get generated end-to-end, capture, mockup, export, without me opening Figma or Photoshop
• Reddit runs every day without me thinking about it
• Deploy is one command (or a cron)
• Warnings surface before I even see them

It’s not perfect. There are still manual tasks, decisions I need to make, stuff that breaks. But the “what am I forgetting?” in my head has almost disappeared.

Why it scales

The pattern is simple: one agent = one capability.

If tomorrow I want an Instagram presence, I create an “instagram-posting” skill and assign it to the marketing agent. If I want perf monitoring, I add a skill to the ops agent. If I launch a new app, I add its product sheet to the workspace and every agent sees it.

No need to refactor the architecture. No need to touch other agents. Plug in a new module and it runs.

Same principle as microservices, but for agents. Except instead of coding APIs, you write instructions in plain language.

The real benefit

For a solo indie dev, this setup changes everything. It’s not just about saving time. It’s a shift in posture.

Before, I was dev + marketer + ops + QA + PM. I did everything, poorly, and late.

Now I have a small virtual team running 24/7. It’s not perfect, needs supervision, and you have to invest time to set it up. But once it’s done, the effort-to-output ratio is unmatched.

In the morning, I get a briefing on Telegram. Reddit posts are already out. Code is clean. Dependencies are up to date. And I can focus on the only thing that truly matters: building the product.

It’s not magic. It’s infrastructure.

And like all good infrastructure, once it’s in place, you wonder how you ever lived without it.