Practical Implementation: Building Skills and Fitting Them Into the Agent Architecture

The previous three subtopics covered the 3-layer MECHANISM; this subtopic covers how to actually BUILD skills, and where they fit relative to the other pieces of an agent system you might already be using.

This course frames a Skill conceptually first: think of a Skill as a packaged procedure — a complete, reusable workflow that teaches the agent how to perform a task with consistency. Instead of re-explaining steps, examples, constraints, and edge cases every time, you define the workflow once and reuse it forever. It's the AI equivalent of an operating manual: structured, repeatable, and self-contained.

This course's creation process, Building Your Own Skills, is straightforward and has five steps: (1) identify a workflow you repeat constantly — the starting point is always a real, recurring pattern, not a hypothetical one; (2) create a skill folder and add a skill.md file — the container everything else lives in; (3) write the YAML front matter + full markdown instructions — populating both Layer 2 (the trigger descriptor) and Layer 3 (the actual procedure) from the previous subtopics; (4) add any scripts, examples, or supporting resources — the zero-token-until-used tier from the previous subtopic; and (5) zip the folder and upload it in Claude's capabilities — the deployment step. This course notes Claude Desktop even includes a 'Skill Creator' skill that helps generate the structure for you — a skill that helps you build skills.

Just as important as building a skill is knowing where it fits among other agent-architecture concepts you may already know. This course is explicit: Skills don't replace Projects, Subagents or MCP — they complement them. Projects organize your workspace. MCP connects Claude to tools and external services (the full MCP protocol is covered extensively elsewhere in this curriculum). Subagents handle delegated reasoning (covered in the multi-agent-orchestration-patterns topic). Skills package the reusable expertise that all of them can rely on. Each solves a different layer of the agent problem, and skills serve as the procedural knowledge base.

Put plainly: MCP gives an agent the ABILITY to call a tool; a Skill tells the agent HOW and WHEN to use that ability correctly and consistently for a specific recurring workflow, without re-explaining the procedure every time. A Subagent might use several Skills while carrying out its delegated task. Projects provide the workspace all of this happens within. None of these four concepts substitutes for the others — a well-architected agent system typically uses all four together, each doing its own distinct job.

# Implementing the 5-step Skill-building process as a runnable
# checklist/builder, and modeling how Skills relate to (rather
# than replace) Projects/MCP/Subagents.

class SkillBuilder:
    """Walks through the book's 5-step Skill creation process."""
    def __init__(self):
        self.steps_completed = []

    def identify_workflow(self, workflow_description: str):
        self.steps_completed.append(f"1) Identified recurring workflow: {workflow_description}")
        return self

    def create_skill_folder(self, skill_name: str):
        self.steps_completed.append(f"2) Created skill folder + skill.md for '{skill_name}'")
        return self

    def write_content(self, yaml_frontmatter: str, skill_body: str):
        self.steps_completed.append("3) Wrote YAML frontmatter (Layer 2) + markdown body (Layer 3)")
        return self

    def add_supporting_resources(self, resources: list[str]):
        self.steps_completed.append(f"4) Added supporting resources: {resources}")
        return self

    def deploy(self):
        self.steps_completed.append("5) Zipped and uploaded to Claude's capabilities")
        return self

builder = (
    SkillBuilder()
    .identify_workflow("Processing customer refund requests")
    .create_skill_folder("refund-processing")
    .write_content("name: refund-processing", "Step 1: verify order...")
    .add_supporting_resources(["refund_email_template.txt", "eligibility_checker.py"])
    .deploy()
)
for step in builder.steps_completed:
    print(step)

# How Skills relate to the other agent-architecture pieces:
agent_architecture = {
    "Projects": "organizes the workspace this agent operates in",
    "MCP": "gives the agent the ABILITY to call external tools/services",
    "Skills": "tells the agent HOW/WHEN to use that ability for a recurring workflow",
    "Subagents": "handle delegated reasoning, often using several Skills along the way",
}
print("\nHow the pieces complement each other:")
for piece, role in agent_architecture.items():
    print(f"  {piece}: {role}")