How I Taught AI to Work Like a Team
Every AI conversation starts from scratch. You explain the same context, lose the same work, repeat the same mistakes. The next session has no memory of the last one.
After a year of building on top of Claude Code, I stopped trying to have better conversations and started building a team instead. Specialists who know specific systems. Standard procedures for recurring tasks. An office handbook with rules everyone follows. And a shared drive where everything gets written down so nothing gets lost between sessions.
The Team
Instead of one chatbot that tries to do everything from memory, the system works more like a small organization. Each layer has a role:
Specialists
I have team members who each know one system deeply. One knows every campaign finance filing in South Carolina. Another can search 200 years of property deeds in Greenville County. Another tracks Tennessee election data across 14 counties. Others handle my calendar, email, task management, and file storage.
These are built using the Model Context Protocol (MCP), which gives the AI structured access to external systems. Each specialist handles the messy details of one data source so I can just say "look up this person's campaign contributions" without knowing how the state ethics commission website works.
Four of these specialists are custom-built and open source. The rest connect to services like Google Workspace, Airtable, Slack, and Dropbox through third-party tools.
The Handbook
Every good team has policies that everyone follows without being told each time. I have about 20 of these, covering everything from writing quality to email safety to which AI model to use for which task. They load automatically into every conversation.
Example: Writing quality standards
A checklist of patterns that make AI-generated text obvious -- banned words ("delve," "utilize," "robust"), structural tells (the "It's not X, it's Y" formula is the single biggest giveaway), and formatting red flags. Every piece of text passes through these filters automatically. The full checklist is published here.
Example: Protecting focused work
Rules that keep me from spending an entire session on busywork. If the conversation has been 30+ minutes of task management without touching an actual deliverable, the AI says so. If I'm starting something new while three other things are mid-flight, it surfaces the list. Before optimizing a workflow, it asks: "Does this address your actual bottleneck, or does it speed up something that isn't the constraint?"
Example: Email safety
Hard rules for what the AI can and cannot do with my email. Never send without showing me the draft first. Never delete messages. Never mark anything as read -- that's my own triage signal. Always verify the recipient before sending. These rules make it safe to give the AI broad access without worrying about an errant send.
Standard Procedures
When a task matches a documented workflow, the AI follows the procedure instead of improvising. I have over 20 of these, covering everything from campaign onboarding to document scanning to data cleanup.
The best ones came from failure. The checkpointing procedure exists because a planning session once took four separate conversations -- the AI kept filling up its context window before writing anything down. The fix was simple: treat the context window like short-term memory (it forgets) and the filesystem like long-term memory (it persists). Write things down every few minutes, not at the end. That one rule eliminated the problem entirely. The full guide is published here.
Other procedures cover data deduplication, DNS and email authentication, AI image generation with identity preservation, and large document processing. Each one represents hours of trial and error distilled into a repeatable process that I -- or anyone -- can follow.
Automated Routines
Some procedures trigger automatically based on what I say. When I say "scan my inbox," a routine kicks in that classifies emails, checks for duplicates against existing tasks, and drafts entries for review. When I mention a client's name, the system silently loads that client's project file so it has the full background. When a session ends, a wrapup routine runs through a checklist: log anything we learned, update project files, flag stale information.
These are the part of the system that feels most like having a good assistant. You don't have to explain the procedure every time or remember to do the housekeeping. The routines handle it.
The Shared Drive
The reason every AI conversation starts from scratch is that the AI's memory is temporary. When the conversation ends, everything in it disappears. The shared drive is the fix: everything important gets written to files that persist between sessions.
Every client project has a file that acts as the single source of truth: current work status, key contacts, relevant links, and a dated log of what happened when. When a new session starts, the AI reads the file and picks up where the last one left off. There's also a running log of mistakes and corrections that compounds over time -- by the fifth session, the AI catches errors it used to repeat.
The principle throughout: if it matters, write it down. If it's only in the conversation, it's temporary.
What This Adds Up To
On a typical day, I might say "catch me up on the Greenville project." The AI loads the project file, scans recent emails, checks for open tasks, and puts together a briefing. It knows my writing standards, my email rules, which tools to use for what, and which mistakes to avoid. None of that required me to explain anything. The team remembered.
No single piece here is complicated. The specialists are just connections to databases. The handbook is just a set of text files. The procedures are just documented workflows. But stacked together, with shared memory connecting one session to the next, the whole thing compounds. Every mistake logged prevents a future mistake. Every procedure refined from experience makes the next run smoother. That's what makes it feel less like a chatbot and more like a team.
The tools and guides on this site are pieces of that system, published for anyone to use or adapt.
Build Your Own: A Starting Point
You don't need to build all of this at once. Start with one layer and add as you go. Here's how to get from zero to a working system in an afternoon.
Step 1
Create a project directory and open Claude Code in it
This directory becomes your "shared drive." Everything the AI writes will live here.
mkdir my-ai-workspace
cd my-ai-workspace
claudeStep 2
Create your first "handbook" entry: a CLAUDE.md file
This is the file Claude Code reads at the start of every conversation. Tell it who you are, what you care about, and how you want it to behave. Start simple. A few lines is fine.
# CLAUDE.md
## About Me
I'm a [your role]. I work on [what you do].
## Rules
- Be direct and concise
- Don't add features I didn't ask for
- Write findings to disk, not just in conversationStep 3
Add a project file
Create a PROJECT.md for whatever you're working on. This is your persistent memory. At the end of each session, tell the AI to update it. At the start of the next session, it reads the file and picks up where you left off.
# PROJECT.md
## Current Work
- Working on [what you're doing]
## Key Decisions
- [decisions made so far]
## Update Log
- 2026-04-11: Started projectStep 4
Add your first "specialist"
Connect a tool the AI can use. The simplest starting point is one of the existing MCP servers -- they take one command to install. For example, to give your AI access to your Google Calendar and email:
claude mcp add google-workspace -- uvx workspace-mcpNow the AI can read your calendar, search your email, and manage your Drive files. You can also install any of the open-source MCP servers from my tools page.
Step 5
Write your first procedure when you catch yourself repeating something
The second time you explain a workflow to the AI, stop and write it down. Create a playbooks/ folder and save it there. Next time, the AI follows the procedure instead of you explaining it again.
Step 6
Add rules when you find yourself correcting the same mistake
Create a .claude/rules/ folder. Each rule is a markdown file that loads automatically. The first time the AI does something you don't like -- uses a word you hate, formats something wrong, takes an action without asking -- write a rule so it doesn't happen again.
That's the whole pattern. Start with a directory and a CLAUDE.md. Add project files for memory. Connect tools for capability. Write procedures when you repeat yourself. Write rules when you correct mistakes. Over weeks and months, the system accumulates knowledge and gets better at working the way you work. That's what compounding looks like.
April 2026