Practical Guide: Building Real AI Systems with Claude Workflows, Skills, Subagents and Agent Teams

1) Understand the Real Constraint First

Context and Token Economics

Every AI request consumes part of a limited context window.

And almost nobody manages this properly.

Example from the course:

• System tools + MCP tools already used ~40K tokens
• Memory + skills pushed it near ~45K tokens
• Before the user even typed a message

That means:

You already lost a large percentage of reasoning quality before work started.

Why this matters:

The beginning of a prompt = highest intelligence quality

If tools consume that space → decision quality drops.

MCP Problem

MCP integrations are convenient but expensive.

Example:

One ClickUp MCP tool used more tokens than all Skills combined.

So:

MCP = convenience

Skills = efficiency

Therefore the workflow:

Prototype with MCP → Replace with Skill

2) The Correct Development Order

Never start with agents.

Use this hierarchy instead:

1. MCP integrations for testing feasibility
2. Skills for reliable workflows
3. Subagents for speed
4. Agent teams for scale

Each layer solves a different problem.

3) Skills: The Most Important Concept

A Skill is a reusable intelligence module.

Not a prompt

Not a template

Not a chatbot personality

It is a repeatable behavior unit.

Why Skills are Efficient

Only the front matter loads into context:

• name
• description
• allowed tools

The full instructions load only when needed.

Result:

Massive token savings

Better reasoning quality

Consistent outputs

Example Workflow: Email Classification

Step 1 — Prototype with MCP

Goal:

Automatically label emails.

Process:

1. Connect Gmail MCP
2. Fetch emails
3. Classify
4. Apply labels

Works but slow and token heavy.

Step 2 — Convert to Skill

Instead of MCP:

Call Gmail API directly

Now:

• Faster
• Cheaper
• Reliable

Result:

100 emails processed in ~36 seconds → reduced dramatically

Thousands of emails become feasible

Key idea:

If a task repeats, convert it to a Skill.

4) Subagents: Parallel Execution Layer

Subagents are not smarter.

They are workers.

Parent agent = manager

Subagents = processors

Use them only when work can be split.

What They Are Good For

Large classification

Research

Bulk processing

Data transformation

Not good for:

Complex reasoning

Decision making

Keep the parent agent responsible for decisions.

Parallel Processing Example

Instead of:

Process 1000 emails sequentially

Do:

Split into 10 subagents

Each processes 100 emails

Speed increases dramatically.

But new constraint appears:

Probability failure compounds.

If one agent success = 95%

10 agents success = 59%

Therefore:

Subagents should do simple tasks only

5) Subagent Design Pattern

Correct architecture:

Parent agent:

• defines task
• merges outputs
• validates results

Subagents:

• classify
• fetch
• analyze chunks

Never let subagents orchestrate.

6) QA, Research and Code Review Agents

Create specialized subagents:

Research agent

Finds documentation and references

QA agent

Generates tests and verifies logic

Code reviewer

Finds bugs and inefficiencies

Workflow:

Parent writes code → reviewer checks → QA tests → parent fixes

This mimics a real engineering team.

7) Agent Teams: Large Scale Coordination

Agent teams are hierarchical parallel systems.

Subagents split one task.

Agent teams split entire workflows.

Structure:

Manager agent

→ team agents

→ subagents under each team agent

They communicate through shared memory.

When to Use Agent Teams

Large codebase analysis

Security audits

Mass research

Multi-design generation

Not normal automation.

They are expensive.

Token usage increases rapidly because every agent has full context.

Example: Security Audit

10 scanner agents analyze files

2 debate agents validate findings

Multiple fix agents implement corrections

Cost: high

Speed: extremely high

This trades money for time.

8) Parallel Thinking Principle

Serial execution:

Task A → B → C = 3 minutes

Parallel execution:

A, B, C simultaneously = 1 minute

This is the entire reason agents exist.

Not intelligence.

Throughput.

9) Git Worktrees with AI

Problem:

Multiple agents editing same code causes conflicts.

Solution:

Each agent works on a separate branch.

Workflow:

Main project

→ About page agent

→ Contact page agent

→ Services page agent

Then merge changes.

This prevents collisions and allows safe parallel development.

10) Turning AI Workflows Into Real Products

The course moves from AI thinking → deployment.

Key shift:

Chat output = worthless

Accessible endpoint = product

Build APIs Instantly

Create public URLs that run workflows.

Examples:

• Lead scraper
• Classifier
• Proposal generator
• Labeling engine

Each becomes callable by:

n8n

Zapier

Make

Webhooks

Now AI becomes infrastructure.

11) Real Automation Stack

Final architecture:

Decision Layer → AI agent

Execution Layer → automation platform

Action Layer → APIs

Example:

AI analyzes lead quality

n8n triggers workflow

API sends messages and updates CRM

AI thinks

Automation acts

12) Practical Operating Rules

1. Never load everything into context
2. Replace prompts with Skills
3. Use MCP only to test
4. Use subagents only for chunkable tasks
5. Use agent teams only for massive workloads
6. Keep reasoning centralized
7. Convert workflows into endpoints
8. Connect endpoints to automation tools