I'm one person, and I have eleven products at varying stages — some live on app stores, some self-hosted, some still in private beta. People assume the trick is working more hours. It isn't. The trick is an AI-assisted dev workflow where agents do the typing and I do the judging, structured tightly enough that I can context-switch between a Flutter pet app and a Django trading platform without losing my mind.
This is the meta-story behind the portfolio. I want to be specific about what actually works, because "I use AI to code" is a slop sentence that means nothing. The interesting part is the structure around the AI: the loops, the specs, the reviewers, and the places where leaning on agents quietly cost me.
Spec-driven autonomous loops
The single most useful pattern I run is an autonomous build loop driven by a queue of specs. LaunchPad, my product-launch automation platform, was built almost entirely this way through what I call an /evolve loop: it commits one task per cycle against an EVOLUTION.md queue, then moves to the next. Roughly 40 evolution tasks across 7 phases got it to where it is now.
The constraint that makes this work is "one committed task per cycle." It forces the agent to finish something — a real, reviewable, committed change — before it's allowed to start the next thing. That's the opposite of the usual AI failure mode, where you ask for a big feature and get back 600 lines of plausible code that touches twelve files and compiles but doesn't actually work end to end. A queue of small, ordered specs keeps the agent on a leash, and it keeps me able to review changes in chunks small enough to actually understand.
The specs themselves carry the weight. On TradingHub, my paper-trading crypto platform, the strategy work is driven by 242 markdown research specs feeding an autoresearch and evolution loop. Each spec is a contained piece of intent — a strategy idea, a risk rule, a model to wire in — written down before any code exists. When the intent lives in a versioned document instead of in a chat window, the agent has something durable to build against, and I have something to review that isn't just a diff.
The agent arena: making models compete
Here's the part of the TradingHub workflow I find most interesting. Those research specs don't just feed one model. They feed an arena where Claude and Codex compete on the same task. Two different agents, same spec, and I get to compare the outputs instead of trusting whichever one I happened to ask.
This matters more than it sounds. A single agent is confidently wrong in consistent ways — it has habits, blind spots, a house style of bug. When you put two different models on the same spec, their disagreements are a signal. Where both arrive at the same approach, I trust it more. Where they diverge, that's exactly the spot that needed a human to think. The arena turns "is this code right?" into "here are two attempts, what does their difference tell me?" — a much easier question to answer well.
It's not free. Running two models on everything costs more tokens and more of my attention, so I reserve it for the parts where being wrong is expensive — the risk gates, the signal-fusion logic — and let a single agent handle the boilerplate.
Adversarial self-review
The pattern I'm most glad I adopted is adversarial review, and Anima — my AI life-management system — is where it earned its keep. Anima's development runs an adversarial self-review culture: three independent reviewer agents whose only job is to assume I got it wrong and go looking for proof.
They found proof. Across the build they caught and fixed a Cypher injection vulnerability, an IDOR (insecure direct object reference), and TOCTOU (time-of-check to time-of-use) race conditions. None of those are exotic. They're exactly the class of bug a solo founder moving fast ships without noticing, because the happy path works and the demo looks fine. There's no second engineer to catch them, so I manufacture one — three, actually — out of agents pointed at my own code with hostile intent.
The reason this works where "please review my code" doesn't is the framing. An agent asked to review tends to be agreeable; it nods along and finds nits. An agent told its job is to break the code, find the injection, prove the authorization is bypassable, behaves completely differently. The adversarial stance is the whole trick. I lean on a version of it across everything I build now, because the alternative is finding out about the IDOR from a user.
The anti-slop discipline
There's a cultural rule under all of this that I hold deliberately, and it's the same instinct that makes the rest of the workflow trustworthy. Anima has an explicit "anti-AI-slop" mandate: no fake metrics, no stock art, no emoji CTAs, hold a Linear/Stripe-quality bar. It reads like a design preference. In practice it's an engineering constraint that points straight at the failure mode of AI-assisted work.
"No fake metrics" means the product can't display a confidence score it never computed. That's the same discipline as the EvalGate that makes Anima's AI refuse to answer rather than hallucinate about your life. An AI that pads its output with plausible-sounding filler is producing slop, whether that output is a UI or a paragraph or a function. Building to a real-quality bar rules out most of the shortcuts that make AI-built products feel cheap — and it's why every claim in these articles is grounded in what the repos actually contain, not what would sound impressive.
CLAUDE.md and per-project agent config
None of this scales across eleven products without per-project memory. Every repo carries a CLAUDE.md and its own agent configuration — the project's conventions, its architecture, the commands that matter, the things an agent must not touch. PokiPaw, my six-platform Flutter pet-care app, is a good example: its repo shows the heavy AI-assisted workflow plainly, with CLAUDE.md, agent configs, strategy and pre-mortem docs, and dozens of localization patch scripts that pushed it into seven-plus languages.
That localization automation is the unglamorous payoff. Translating and maintaining a mobile app across EN, RO, DE, ES, FR, ID and ZH by hand is the kind of repetitive, error-prone work that burns a solo founder out. Scripting it — having agents generate and patch the l10n files against a known structure — is exactly the chore AI should own. The CLAUDE.md is what makes the agent reliable at it: when the conventions live in the repo, I don't re-explain the project every session, and a fresh agent picks up where the last one left off.
Where AI helps, and where it creates debt
I want to be honest about the cost, because the workflow has a real downside and pretending otherwise would be its own slop.
AI is genuinely excellent at: scaffolding, boilerplate, localization, wiring up known patterns, exploring a design two ways at once, and reviewing with hostile intent. It compresses the work where the answer is largely known and the labor is the bottleneck. That's most of how eleven products exist.
But agents will happily build you a bigger system than you need, one reasonable task at a time, and you won't feel it until two halves of the codebase disagree about reality. LaunchPad is my cautionary tale. It started narrow — automate the launch posting — and the evolve loop kept saying yes: competitor tracking, AI-search visibility, ASO, influencers, email outreach. Each addition made sense alone. Together they produced a split brain, where half the system thought in "launches and channels" and the other half had become a general marketing-intelligence suite, and the data model couldn't agree on what the central object was. An audit forced a project-first refactor to reconcile the two. That was the most valuable week of work the project got, and the debt that made it necessary was a direct product of an autonomous loop that never paused to ask "what is the central thing here?"
The lesson I took: autonomous loops are great at execution and terrible at saying no. The architectural judgment — what to build, what to refuse, when the model of the world has drifted — is the part that stays mine. The agent commits one task per cycle; deciding whether that task should exist is the job AI hasn't taken.
There's a second, sharper cost. Moving this fast across this many repos makes it easy to leak things — a TradingHub README once exposed an admin credential that should never have been committed. That's the kind of mistake velocity produces, and it's exactly why the adversarial reviewers and the anti-slop bar aren't optional luxuries. They're the brakes.
The shape of it
Strip away the specifics and the workflow is: write intent down as specs, let a leashed loop execute one committed task at a time, make models compete where being wrong is expensive, point hostile reviewers at the result, hold a real-quality bar, and keep the architectural "should this exist?" judgment firmly human. The AI does the volume. I do the no.
If you want to see these patterns in the wild, they're most visible in LaunchPad's evolve-loop build and the refactor that followed, in TradingHub's Claude-vs-Codex arena and 242 research specs, and in Anima's adversarial three-agent review culture. All of it ties back to the bigger picture: the eleven products I'm building as a solo founder. I write these up as I go — if the workflow is your kind of thing, the newsletter is where the next teardown lands first.