Building Your AI Squad: First Specialist

The Pitch

Here's a number that should concern you: 73% of people who "use AI regularly" are doing the same thing they did in 2023. Paste text in. Get text out. Maybe ask it to write an email. Repeat forever.

Meanwhile, the 27% have built systems. Not complicated systems—simple, ugly, effective little engines that run recurring tasks while they do other things. The gap between "I chat with AI" and "I have AI workers" is not about intelligence or technical skill. It's about a specific cognitive move most people never make.
This workshop teaches that move.

The failure isn't intelligence. Modern LLMs are absurdly capable. The failure is architecture. You're asking one generalist to do seventeen different jobs—planning, researching, drafting, editing, checking, formatting—and expecting it to context-switch as gracefully as you do. It can't. Context windows have limits. Attention has limits. Prompts optimized for creative generation actively fight prompts optimized for rule-following.

The Fix

Stop treating AI as one brain and start treating it as a hiring problem.
When you need diverse work done, you don't hire one person who does everything badly. You hire specialists. A researcher who goes deep. A writer who drafts fast. An editor who catches what the writer missed. A project manager who keeps the pieces moving.

That's what this workshop builds: the mental model and practical scaffolding to turn one AI into a squad of specialists with distinct jobs, distinct prompts, and—optionally—distinct tools.

What You'll Build

Part One (this workshop): You'll arrive with a task you hate doing. You'll leave with a functioning specialist prompt that actually handles it—tested on real input, refined through peer feedback, slotted into a workflow you can run next week.

Part Two: You'll decompose that workflow into a team of agents that coordinate, hand off work, and catch each other's mistakes. You'll design memory and tool requirements. You'll sketch an implementation you can actually build.

Two tracks available: If you code, you'll sketch an implementation in Python or whatever framework you prefer. If you don't, you'll design something you can run with copy-paste, saved prompts, and tools you already have.
Both are valid. Neither is better. Pick based on what you'll actually do.

The Evolution Ladder

Before we get tactical, let's establish a map. Most people are stuck at Stage 1 without knowing there are other stages.

Stage 1 — Single LLM Conversations
You open ChatGPT. You ask a question. It answers. You close the tab. No memory, no structure, no compounding value. This is where most people live permanently. It's like having a genius available 24/7 and only asking them to proofread.

Stage 2 — Prompted Specialist
You write a system prompt that defines a specific job. The AI becomes a "Weekly Report Writer" or "Email Triage Assistant" with clear inputs, outputs, and constraints. Suddenly it's not a genius—it's an employee with a role. Same underlying capability, vastly more useful.

Stage 3 — Agent with Tools & Memory
The specialist can now access things: browse the web, read files, remember past interactions. It's not just transforming text—it's gathering information, maintaining context, acting on your behalf. This is where things get interesting.

Stage 4 — Multi-Agent Teams
Multiple specialists coordinate. A "Research Agent" hands off to a "Writing Agent" which passes to an "Editing Agent." They critique each other. They iterate. You become a manager, not a worker.

Stage 5 — Automated Workflows
Triggers fire without you. New email arrives → classification agent runs → if urgent, drafts response → schedules follow-up. You've built a small bureaucracy that operates while you sleep.

This workshop covers Stages 2 through 4. That's where the 27% separated from the 73%. It's also where the mechanics are learnable in a single session.

What Makes a Task Automatable?

Not everything should be handed to AI. The good candidates share these properties:
Text-based: AI processes language. If your task involves spreadsheets, images, or physical objects, the setup gets complicated. Start with text.
Recurring: A task you do once isn't worth systematizing. Something you do weekly? Monthly? That's worth the upfront investment in clarity.
Rule-followable: If you could write down instructions for a competent human assistant, you can write them for AI. If the task requires judgment you can't articulate—"I just know when the client is annoyed"—AI will struggle.
Not catastrophic if wrong: Start with tasks where mistakes are annoying, not career-ending. You can hand off higher-stakes work after you've learned to verify outputs.
The sweet spot: something you do every week, that involves reading or writing text, that you could explain to a new hire in five minutes, that you find slightly tedious.

Bad example: "Make creative decisions about my brand strategy"
Good example: "Turn my rambling meeting notes into bullet points with action items highlighted"

Pre-work: Specialist Foundation (35-45 min)

The workshop's value depends on whether you arrive with real material from your real life. Skip this and you'll spend the whole session catching up while everyone else makes progress.

Step 1: Task Excavation (10 min)

Open your calendar, email, to-do app—whatever records what you actually did the last three days. Write down 15 tasks you completed. Don't filter. Don't judge. Just list. Include work tasks (writing, replying, researching, planning), personal tasks (budgeting, coordinating, organizing), side projects, community stuff—anything you spent time on.

For each task, add a quick label:
T = Text-heavy (emails, notes, writing, summarizing)
R = Research/info-finding
P = Planning/prioritizing
M = Mindless/repetitive (copy-paste, status updates, reformatting).
Tasks can have multiple labels. Don't overthink it.

Step 2: Target Task (10 min)

Circle one task that matches all three criteria: it happens at least weekly, involves text, and you're kind of sick of doing it.

Give this task a working name. Be specific:
Not: "Emails" → Better: "Weekly update email to my manager about what the team shipped"
Not: "Meeting notes" → Better: "Turning Sarah's chaotic Zoom transcript into something I can send to stakeholders"

Now write a single paragraph answering: "If I had a competent assistant who handled this task perfectly, what would they do from start to finish? What would they need from me? What would I get back?"

Step 3: Draft Your Specialist Job Card (15 min)

Translate your paragraph into structured format:

**ROLE**: You are [specific role name].

**YOUR JOB**: [2-3 sentences describing what success looks like]

**INPUT**: You will receive:
- [What kind of text? Be specific about format and length]
- [Any additional context needed?]

**OUTPUT**: You will return:
- [Exact structure. Headers? Bullets? Maximum length?]

**CONSTRAINTS**:
- [Tone requirements]
- [Hard rules — things to always do or never do]
- [Quality thresholds]

Real Example

**ROLE**: You are my Weekly Update Email Drafter.

**YOUR JOB**: Transform my rough bullet points about team progress
into a professional email for my manager. Maintain accuracy—don't
add accomplishments that aren't real. Keep it scannable. Make me
look competent without sounding like I'm overselling.

**INPUT**: You will receive:
- Bullet points of what happened this week (usually 8-15 items)
- Any specific concerns or questions I want to flag
- Deadline pressure (if the week was good or rough)

**OUTPUT**: You will return:
- Subject line (specific, not generic)
- Email body: 200-300 words max
- Three sections: Highlights, In Progress, Needs Attention
- Closing that sounds like me (professional but not stiff)

**CONSTRAINTS**:
- Never promise deliverables I didn't list
- Don't use corporate buzzwords (synergy, leverage, circle back)
- Highlight blockers only if I flagged them as blockers
- End with specific question if I included one, not generic

Step 4: Test It (optional, 10 min)

If you have access to an LLM:

1. Paste your job card as the first message
2. Send a real (or realistic) example input
3. Observe what comes back
   Note three things: What did it get right? What did it mess up? What did you forget to specify? Bring these observations. They're gold.

Surface Patterns (15 min)

Lightning Round

Everyone names their chosen task in one sentence. No explanations, no context. Just the task name.

Track patterns in a shared document or whiteboard. You'll see clusters: email management (usually biggest), meeting follow-up, status reporting, content creation, research synthesis. Point this out. These are the recurring pain points of knowledge work.

Set the Stakes

Share the most annoying thing about your task. Not the hard parts—the annoying parts. The friction that makes you procrastinate.

Prompt Clinic (25 min)

You're about to do two activities: sharpen your specialist prompt so it's actually useful, then sketch how this specialist fits into a workflow you'll build out next time. Perfection isn't the goal. Progress is. A working 70% solution beats an imagined 100% solution.

Split into pairs or threes for this activity, setting a return time that includes a 5 minute break.

Read your job card aloud. Share your test results if you have them. If not, share what you think will go wrong.

Partners respond:

1. Restate what they think the specialist's job is. (This reveals ambiguity.)
2. Identify one thing that seems underspecified.
3. Suggest one constraint that might prevent disaster.

After everyone has gone, revise your job card. Focus on making input format more explicit, adding 2-3 "always/never" rules, and tightening the output structure. Common Failure Modes to Flag
"Tone is too vague" — "Professional" means nothing. "Sounds like me: direct, occasionally sarcastic, never uses exclamation points" means something.
"No failure handling" — What should the AI do if the input is incomplete? Build in graceful degradation.
"Output format handwaving" — "Give me a summary" is useless. "5-7 bullet points, each starting with an action verb, max 15 words per point" is actionable.

Break (5 min)

Drink some water, move, and let your brain rest a moment.

Workflow Sketch (25 min)

Draw three boxes:

[INPUT SOURCE] → [SPECIALIST] → [OUTPUT DESTINATION]

Then fill them in:
Input Source: Where does the raw material come from? How often does new input appear? What's the current format?
Specialist: Name of your specialist. 3 core transformations it performs. What it assumes vs. what it needs to be told.
Output Destination: Where does the result go? Who sees it? What happens after?

Make additional annotations: List one tool your specialist would need to be more useful (email access, web search, file reading, calendar integration).
List one memory that would make it smarter (your preferences, past decisions, context about stakeholders).

MVP (5 min)

If you had to ship just Box 1 → Box 2 this week, what's the simplest version?
Record and share your answer.

Commitment Round (10 min)

Give your elevator pitch (30 seconds):

1. The task I'm targeting
2. The simplest version I'm shipping this week
3. What would make me confident this is working

Push for specificity. Reject: "I'll try my prompt a few times." Accept: "Wednesday I'll run this on my actual status bullets and compare to what I wrote manually."

Final Question (5 min)

What's one thing you learned about your task from trying to systematize it?