I'm one engineer with an AI team. Here's how I ship agency-sized work alone

On 5 November I started the day without a list of article topics. By the end of it, four researched articles were live on my site, each with its own interactive tool, social image, sitemap entry and a Google indexing request.

I didn't write them faster. I ran them the way an agency runs a project: research, writing, review and release, with several people working at once. The difference is that most of those people are AI agents, and I'm the one who decides, checks and signs off.

This is how that actually works, including the parts that went wrong.

The day, in numbers

Research: 3 agents in parallel, one each for payment gateways, ERP/courier integrations and headless/dashboards. Each made 40–46 searches and page reads in about 3.5 minutes. Between them they came back with 26 ranked problems, with sources for the claims.

Writing: 4 agents in parallel, one per article. Each had to read my existing posts first, match their components and tone, verify every fact against primary sources, and list what it dropped as unverifiable.

Shipping: I integrated the four posts, built, checked every page at 390px and 1440px, fixed what I found and deployed. The same day I submitted 4 URLs to Google.

Earlier that week I used the same setup to build a 16-page store-and-admin template: one agent laid the foundation (design tokens, layout, data), then 3–4 agents built page groups in parallel, and I compared every page against the reference in a browser.

What I actually do

People assume the AI does the work and I watch. It's closer to the opposite. The agents are fast and tireless. The judgement is mine:

• Choosing the problem. The first list of topics the agents gave me was the everyday stuff I already fix, so I threw it out. The second round came from a brief I rewrote around one question: what is the market failing at that I've actually built?
• Writing the brief. An agent only knows what I tell it. A good brief names the files to read, the scope, what's off-limits and what "done" means. A vague brief gives you confident, generic work.
• Checking everything. I treat every agent report as a draft from a smart new hire. It's often right, and it's always confident, even when it isn't.
• Saying no. Publishing, passwords and anything that goes out under someone's name stay with a human.

Where it went wrong

This is the part that matters most, because it's where an AI team differs from a real one:

• A calculator that looked right but wasn't honest. One agent built a COD calculator with an input nobody could actually fill in (a guessed "error %"), then turned it into a scary yearly loss figure. Each step looked fine on its own. I spotted it on review, and we rebuilt it to use only numbers from a real courier statement: what you should have been paid, against what you were paid.
• A word nobody could back up. One draft called an app "well-known". No source said so, and the agent flagged it itself. I cut it. Small words like that are how trust goes.
• An agent that stopped halfway. The template's foundation agent ended early with work unfinished. Nothing errored. I only knew because I checked what it had actually written to disk.
• A test environment lying to me. My local server kept reloading mid-check because of file syncing. The audit wasn't failing because of the pages. I had to change how I tested before I could trust the result.

None of these showed up as an error. Every one was caught by a check someone decided to run.

The rules that make it work

1. Parallelise the independent work, keep the decisions in one head. Research and drafting fan out. Choosing and merging don't.
2. Give every agent its own files. Two agents never edit the same file. I do the integration.
3. No unsourced numbers. If an agent can't point to where a number came from, it doesn't ship.
4. Verify like an outsider. Open it on a phone width, click the tool, read the page as the customer would.
5. Security runs on a schedule, not on memory. A check runs every day at 10:00 across my projects: leaked keys, open database policies, unguarded functions, secrets in live JavaScript.

Why this matters if you hire developers

A solo developer used to mean small scope. That's no longer true. What you're really buying now is judgement: knowing which problem to solve, writing a precise brief, and refusing to ship what hasn't been checked. The typing is the cheap part.

I'm Fahad, a Shopify and full-stack developer. I work this way every day, and I write up what I build at fahadazhar.site. If you're running AI agents in real projects, I'd like to compare notes. What's broken for you so far?