I Run a Small AI Bot Team Like a Content Operations System

Diagram of four roles — chief of staff, developer, content, and SEO — feeding into a human yes gate before anything is published.
Running a small Grok Bot team became a hands-on lesson in roles, written briefs, review-only drafts, and putting a human yes in front of anything that gets published, sent, or shipped.

I did not set out to build an AI department.

I started using Grok Bot as a content writer who already thinks in terms of briefs, review, and publishing workflows. I wanted help with research, drafts, technical tasks, and the operational work around them.

What I ended up with was smaller and more familiar than that sounds.

There is a chief of staff bot, a developer bot, a content bot, and an SEO bot. I write the brief. They do the assigned work. I review the result. Nothing is published, merged, sent, or spent without my yes.

I built this system because the alternative was a long chat thread and a lot of trust I had not earned yet.

1. What I tried

My original goal was not to assemble a large virtual staff.

I wanted to answer a simpler question:

Could I run a few AI bots the way a lean content team already works, with clear roles, a written brief, and one approval gate?

At first, I asked one bot to cover both operations and technical lead work.

That did not stay useful for long.

In early November, I split that combined role into two: a chief of staff bot, who is the only bot that brings approvals to me, and a developer bot, who owns technical and repository work. Content and SEO work sit in their own roles.

The chain is simple on purpose.

The chief of staff bot coordinates. The other bots do one job at a time. I stay the person who says yes or no.

I also wrote a short set of team rules.

The most useful of those rules, for me, was to start work with a tight done-list brief: the goal, the purpose, the constraints, and three to five pass/fail checks. I asked for one bot per task, one big job at a time, and small changes batched into a single pull-request cycle.

Drafts stay drafts.

Pull requests stay review-only until I approve them.

If I need to think, I pause the team rather than hoping it will stay aligned on its own.

2. Why I tried it

The experiment was partly about using a new tool, but the bigger reason was operational.

As a content writer, I already work around editorial workflows, internal review, and the gap between a draft and something that is actually ready to go live.

I understand those things from the content side.

I wanted to see whether the same ideas would hold when some of the drafting and technical work was done by bots.

Generating text is becoming easier.

Taking responsibility for what was generated is a different problem.

That is the same issue I ran into when I took an unfinished Grok Build export and had to make it my own. The useful work started after the generation stopped.

I also wanted a system simple enough that I could understand it.

If I could not explain who writes, who checks, and who ships, I would not be running a team. I would be hoping a chat window would stay organized by itself.

3. What worked

The biggest thing that worked was the written brief.

A long chat is easy to start and hard to reuse. A done-list brief can be checked.

When I state the goal, the purpose, what not to do, and a small set of pass/fail criteria, the output is easier to review. I can see whether the work met the brief or quietly expanded past it.

Separating roles also helped.

Content work, technical work, and SEO work are not the same job. Neither is the work of bringing a decision to me. Once those were no longer stacked on a single bot, I spent less time untangling who was supposed to do what.

The approval gate is the other part that worked.

I use one path for approvals. The chief of staff bot can prepare the question. I am the only one who can say yes.

That applies to publishing, sending, and spending.

It also applies to code.

A review-only pull request is useful for the same reason a draft article is useful. I can read it, ask for changes, or leave it unmerged. Nothing goes live because a bot finished a task.

Pausing the team also worked, even though it did not feel productive at first.

In early November I stopped all bot-team work so I could plan offline in ChatGPT Pro and be more careful with usage. I have done that more than once since then. The team stays idle until I explicitly say to resume.

That is an operations decision, not a failure.

4. What broke or confused me

One bot doing two jobs created confusion

The first structure asked one bot to be both the operations lead and the technical lead.

That was too much to keep clean.

Handoffs got heavier. Priorities were harder to see. I found myself unsure whether I was getting an operations recommendation or a technical one.

Splitting the roles made the system easier to run, even though it meant more setup at the beginning.

A chat thread is a weak brief

I can have a long conversation and still not have a clear assignment.

The thread contains useful context, but it also contains discarded ideas, side questions, and older instructions. A bot can follow the wrong part of it.

Writing the brief separately forced me to decide what the task actually was before anyone started work.

Thin analytics can look more certain than they are

I also used the team, carefully, for read-only analytics work.

On one of my own projects, I authorized a bot to review Google Analytics 4 and Google Search Console data, and nothing else, while the rest of the team stayed paused.

The temptation, with any early report, is to treat a short window of data as a conclusion.

It is not.

A few weeks of Search Console data on a small site is a hypothesis. It can tell me what to look at next. It is not proof that a page is working, or that a change is required.

I would rather have a cautious read than a confident recommendation built on too little evidence.

Speed makes it easy to ship too soon

Bots can produce drafts and open pull requests quickly.

That is useful, and it is also the risk.

If the system is optimized only for speed, publishing becomes the default. I had to make the default the opposite: review first, and no live changes unless I ask for them.

5. What I learned

The main lesson was that a bot team is only as good as the editorial system around it.

Written briefs beat chat.

It is better to separate who writes, who checks, and who ships than to ask one assistant to do all three.

A human gate still belongs on publishing, sending, and spending.

I also learned to pause the team on purpose.

If I need to plan, or I do not want work running in the background, stopping everyone is part of the workflow. I can think offline, then resume with a clearer brief.

Another rule I now treat as non-negotiable: never let a bot invent numbers.

If a figure did not come from a source I can check, it does not belong in a draft, a report, or a page. That is basic editorial QA, and it matters more, not less, when the first draft can be produced quickly.

I am still the editor.

The bots can help me move work along. They cannot take responsibility for what goes live.

6. How this connects to SEO, content, APIs, and documentation

Content operations is the same shape of problem

In my professional work, a lot of the job sits between search research, drafting, editorial QA, and the systems used to decide what should be published next.

This bot team is a smaller version of that.

Roles, briefs, review checklists, and a publishing gate are not new ideas. I am just applying them to assistants that can work very quickly if I let them.

Directing bots is teaching me technical work

I am not a senior engineer, and I am not trying to present this as if I were.

I am a content writer who is learning the technical side by doing the review work myself.

That means reading pull requests instead of only asking whether the work is "done." It means deciding whether something can be merged. It means understanding, at a basic level, what a deploy will change. It means looking at GA4 and Search Console with a skeptical eye, especially when the dataset is still thin.

I still need help with the underlying implementation.

The difference is that I am no longer only looking at the finished page or the finished paragraph. I am learning to inspect the path that got it there, which is useful for technical writing, documentation, and any content work that depends on what a product actually does.

Documentation should include what did not work

I want to keep using the same structure I use in the Lab: what I tried, what worked, what broke, and what I will try next.

A bot team can make the work look smoother than it was.

The notes should not.

7. What I will try next

I do not want to keep adding bots just because I can.

The current system is useful because it is small enough to understand.

My next steps are:

  • Keep writing tighter done-list briefs before work starts.
  • Keep review-only drafts and pull requests as the default.
  • Practice reading pull requests, deploys, and analytics with the same skepticism I already use on drafts.
  • Document more of what the system gets wrong, not only what it produces.
  • Resume the team only when I have a clear brief.

The interesting part of this experiment is no longer that I can assign work to AI bots.

It is that I am learning how to run that work like a content operation, with a human yes at the end.

Explore the rest of the project

I am documenting these projects as I learn more about the technical side of content work.

You can explore the current experiments in Ed's Lab, browse my professional work, or read more of my learning notes.