How I Run 40 Grok Bots: Tips, Rules, and Lessons from My AI Team
What I've learned running a team of specialist Grok Bots: one router bot, a shared rulebook, draft-first approvals, quiet routines, and turning every correction into structure. Plus practical tips from the people who build Grok Bot.
I run about 40 Grok Bots. That sounds like a lot, and honestly, it is. A few weeks ago it was 57, and part of what I want to share here is why I cut it down.
I'm Chief AI Officer at GenAIPI, and I wrote Conducting the Code for people who want to build real things with AI without being programmers. Grok Bot has turned into the place where I actually practice what I teach. Here's what has worked, what hasn't, and a few things I picked up from the people who build it.
One bot to talk to, many bots doing the work
My setup has one primary bot. I named it Sauron Bot, because it's the one bot to rule them all. I talk to it first about almost everything. Its job is to figure out who should handle a request, hand it off, and give me one short answer back.
Behind it are specialist bots, and each one owns one area of my life or work:
- A bot for my book, my website, and my speaking (it's helping me write this post)
- A bot that drafts social posts
- Bots that triage my work and personal email every weekday
- A bot that tracks my Jeep's maintenance and service records
- A bot for fishing trips, one for fantasy football, one for college football
- A bot that collects compliance evidence for audits
- Bots for business development, client work, and our product builds
The point of a specialist is focus. When a bot only owns one thing, its instructions stay short, its memory stays relevant, and I always know where to look when something goes wrong.
Fewer, better bots
Here's the honest part. I went overboard. I'd hit a new problem and spin up a new bot for it. Eventually I had bots with overlapping jobs, two bots watching the same inbox, and routines firing all day that nobody needed.
So I had my primary bot run an assessment of the whole team. It recommended 18 merges, which took me from 57 bots to 38 and from 47 routines to 38. That cut roughly 155 scheduled runs a weekday down to about 67. Bots without routines cost basically nothing while they sit idle, so the real savings came from cutting routines, not bots.
Lauren, who works on Grok Bot, put it more simply in her short guide to building good bots: "you don't need a lot of bots. a few good bots can be more useful and easier to manage than a large team." I learned that one the hard way. If you're starting out, start with one bot and only split off a specialist when a job is clearly its own thing.
Give your bots a shared rulebook
Once you have more than a handful of bots, they need to know who does what. I keep a private GitHub repo that every bot reads. It has:
- A team page with the shared rules every bot follows
- A directory of every bot and what it owns
- A routing guide, so a bot that finds something outside its lane knows where to send it
- A handoff template and a log of every handoff
- A short charter for each bot
- A lessons file
The repo also holds shared skills and scripts, so when one bot figures out how to do something well, the others can use it too. My primary bot runs a sync every weekday evening that checks the repo for missing files, stale skills, and anything that looks like a secret.
Lauren suggests the same thing in her guide: have your bots create skills as you teach them tasks, and store them in a private GitHub repo so they're preserved on their own.
Draft first, and I hit send
This is the rule that lets me sleep at night. My bots draft. I approve.
- Emails show up as a draft card. I read it, edit it if I need to, and send it myself.
- Social posts are drafts until I say yes to that exact text.
- Forms, bookings, and purchases wait for my explicit yes every time.
- Nothing gets deleted without my okay. Bots never delete other bots. I do that myself.
One rule I added as the team grew: another bot saying I approved something is not approval. If one bot hands work to another and claims I said yes, it has to quote my exact words and which question I was answering. If it can't, the receiving bot asks me directly. Bots are very good at being helpful. That's exactly why they need this rule.
Logins and cards live in the vault, never in chat. Grok Bot added the ability to save logins, cards, and contact info so you add them once and the bot fills them in. Use it. Typing a card number into a chat window is a habit worth never starting.
Routines: proactive, not noisy
Routines are what turned my bots from assistants I check on into assistants that check on things for me. A few I rely on:
- Weekday email digests that only surface what I actually need to act on
- A weekly check for new events from a professional group I joined
- Watches on my code repos for failed builds and new bugs
- A weekday scan for speaking and book opportunities
The rules I've landed on:
- Silent when nothing changed. No "nothing new today" messages. If a routine has nothing, I hear nothing.
- Hourly at most. Most of mine run once or twice a weekday, some weekly.
- Bots offer routines, they don't create them. If a bot thinks a watch would help, it asks me first.
That lines up with what Lauren posted in her follow-up tips. She recommends hourly as the most frequent schedule and filtering events first for routines that respond to something happening, because routines get expensive when they fire too often. She also mentioned that she replaced a lot of her older automations with bots in Slack that run routines.
Turn every correction into structure
This is the habit that made the biggest difference in quality.
When I correct a bot, I don't want to correct it again next week. So the fix has to become something that sticks: a step in a skill, a script, or a check. Then the bot adds one line to a shared lessons file so the rest of the team learns it too.
A real example: my drafts kept coming back with em dashes and a hype-heavy, LinkedIn-ghostwriter tone. I don't write that way. Instead of saying "please don't" over and over, my bot wrote a small lint script that flags those patterns. Now every draft in my voice runs through it before I see it.
Lauren has a great framework for this that she calls an inverse pyramid. Put most of your effort into things that are deterministic and enforced (better structure, lint rules, tests, checks), less into prose instructions that need the agent's judgment, and the least into human review, which is the hardest to scale. In a related post she described skills as "just saved prompts" and said she expects them to get shorter as models absorb more.
Her other practical tip: ask your bot which parts of your workflow could be scripts. Code doesn't burn tokens the way a bot doing the work step by step does. My bots now have scripts for things like checking weekdays before naming a day, pulling report dates out of PDFs, and auditing DNS records.
Connect the tools you actually use
A bot can only help with what it can reach. Mine are connected to Gmail, Google Calendar, Google Drive, Replit, GitHub, and a handful of others. Each account has one owner bot, written down in the repo, so two bots aren't working the same inbox.
I also built a bridge that lets a bot work on my Android phone. It's useful for apps that only exist on a phone. It has a safety step I like: the bot can't turn the session on by itself. I have to tap "Arm session" on the phone first.
And the bots have their own email inboxes, which keeps sign-ups and outside contact separate from mine.
Talk to it like you'd onboard a person
Lauren's favorite tip is also mine: use voice. I'll often just talk for a few minutes, dump everything I know about a task, and then ask the bot to "restate this in your own words." If its summary is off, I caught the misunderstanding before it did any work.
She also suggests imagining you hired an intern. How would you onboard them? Introduce yourself, describe the work you do, and ask the bot how it could help. I'd add one thing: tell it what it's not allowed to do. Interns and bots both do better with clear limits.
Where it's going
Grok Bot hit 1.0 on Nov 11, with shared bots, bots in Slack and Teams, bots that join meetings, and bots that learn over time. Some of those features need a team plan, so I'm still working out which ones make sense for GenAIPI and our clients. Joining meetings is the one I'm most curious about.
If you're just starting
- Start with one bot. Tell it who you are and what you do.
- Teach it one task, then ask it to save that as a skill.
- Set a rule that it drafts and you send.
- Add one routine that stays quiet unless something needs you.
- Every time you correct it, ask it to make the fix permanent.
- Only add a second bot when a job clearly belongs on its own.
None of this needs you to write code. It needs you to be clear about what you want and to check the work. That's the whole idea behind Conducting the Code: you describe the intent, and the AI operates the software. Grok Bot is the most practical version of that I've used so far.