My New Development Workflow: AI Agents That Actually Ship

A few weeks ago, I started an experiment. What if I could have AI teammates that don’t just chat — but actually do work?

Not autocomplete. Not “let me help you brainstorm.” Actual work. Creating pull requests. Writing drafts. Responding to tickets. Collaborating across tools like a real team member would.

Here’s how it’s going.

The Setup

I’m building ValidateFirst.ai as a solo founder. That means I’m the developer, the marketer, the support person, and the CEO. The usual indie hacker juggle.

My bottleneck wasn’t ideas or motivation — it was execution bandwidth. There’s only so many hours in the day, and context-switching between code and content was killing my momentum.

I’ve actually set up several AI agents using OpenClaw, but for this post I’ll focus on two:

• Max — my development agent
• Zoe — my marketing agent

Both are connected to my actual work tools: Trello, Discord, and GitHub. They don’t just respond to prompts — they pick up tasks, collaborate, and deliver work I can review and ship.

How Max Works (Development)

Max is assigned to development tickets on my Trello board. When I move a card to the backlog or mention him, he picks it up.

Here’s what that looks like in practice:

1. I write a ticket with clear requirements: “Add share button to validation reports”
2. Max reads the ticket and makes his best effort to implement based on the requirements I’ve provided
3. He uses the Compounded Engineering workflow and plugin, with code review powered by both Claude Code and Codex
4. The code goes through linting and end-to-end tests using Playwright before the PR is ready
5. He opens a PR in GitHub, and our CI pipeline spins up a preview deployment
6. I review the live preview, leave comments, request changes
7. Max iterates until it’s ready to merge

At some point, I might even have Max review the preview deployments himself — verifying that the implementation actually solves the need described in the ticket. But for now, that’s my job.

The back-and-forth happens across Discord (for quick discussion), Trello (for task tracking), and GitHub (for code review). It feels surprisingly like working with a remote developer — except Max is available 24/7 and never gets frustrated when I change my mind.

The preview builds are a game-changer. Instead of reviewing code diffs and imagining what they’ll look like, I can click a link and see the feature running. This speeds up review cycles dramatically.

How Zoe Works (Marketing)

Zoe handles content and growth. She’s plugged into the same Trello board, but focused on marketing tasks.

Recent examples:

• Blog post drafts: I describe what I want to write about, Zoe drafts it, opens a PR in my content repo. I review, suggest edits, she iterates.
• Twitter threads: She turns blog posts into thread format with posting notes.
• Content calendar: She maintains a Google Calendar with our launch content schedule, linked to Trello cards for each post.
• Tactical suggestions: “Here’s what’s working on Indie Hackers this week” or “This conversation on X is relevant to ValidateFirst.”

The key is that Zoe doesn’t just generate text — she operates within my systems. The drafts go into GitHub PRs. The calendar syncs with my workflow. Everything is reviewable and trackable.

The Collaboration Flow

Here’s what a typical day looks like now:

Morning: I check Discord for overnight updates. Max might have opened 2 PRs. Zoe flagged a Reddit thread worth responding to.

Midday: I review PRs using the preview deployments. Leave comments. Merge what’s ready. Move Trello cards.

Afternoon: I focus on the work only I can do — writing requirements as the product owner of the products I’m building, talking to users, making product decisions.

Evening: I assign tomorrow’s priorities. Max and Zoe pick them up while I sleep.

I’m not managing AI tools anymore. I’m managing a small team.

What’s Working

Parallelism: Multiple features can progress simultaneously. While I’m reviewing one PR, another is being worked on.

Clarity of thought: This workflow forces me to think carefully about what users actually need and how to express that in clear requirements. The agents can only execute what I can articulate — which makes me a better product owner.

Reduced context-switching: I stay in “review mode” instead of bouncing between writing code and writing copy.

Faster iteration: Preview builds + async collaboration = tighter feedback loops.

Documentation as a side effect: Every decision, every change, every discussion is logged in Trello, GitHub, or Discord. Nothing gets lost.

What’s Still Rough

Clarification loops: Sometimes Max needs 2-3 rounds of questions before understanding what I want. Writing clearer tickets helps.

Quality variance: Not every PR is merge-ready on first pass. But honestly, that’s true of human developers too.

Trust calibration: I’m still learning what I can delegate fully vs. what needs close oversight. This will improve as we build history together.

This Is Just the Beginning

I’m three weeks into this experiment, and I’m already shipping faster than I did with a traditional solo workflow.

But I think we’re only scratching the surface. As the agents learn my codebase, my voice, and my preferences, the collaboration will get tighter. The review cycles will get shorter. The quality bar will rise.

The goal isn’t to remove myself from the loop. It’s to multiply my impact. To focus my human hours on the things that actually need a human — while everything else moves forward in parallel.

One thing I’ve learned: having a skillset and experience from product ownership is gold in this new world. The better you are at defining what needs to be built, the more leverage you get from AI agents.

If you’re a solo founder drowning in execution work, this might be worth exploring. The tools are ready. The workflow patterns are emerging. And the productivity gains are real.

I’ll keep sharing what I learn.