Key Stages in the Agent Skills Learning Path: A 5-Stage Technical Curriculum

The Agent Skills learning path in rohitg00/ai-engineering-from-scratch comprises five sequential stages—Portable Contract and Runtime Boundary, Skill Discovery and Progressive Disclosure, Skill Invocation and Routing, Skill Permissions and Sandboxes, and Skill Evals with Packaging—plus an optional capstone requiring 570+ minutes of hands-on implementation.

The rohitg00/ai-engineering-from-scratch repository provides a structured curriculum for building production-ready agent capabilities. The Agent Skills learning path guides developers through creating secure, portable, and verifiable skill bundles using a progression of five core lessons defined in learning-paths/agent-skills.json. This route transforms learners from basic skill installers into architects of stateless tool ecosystems capable of independent verification and secure runtime boundaries.

Stage 1: Portable Contract and Runtime Boundary

The curriculum begins with foundational mechanics in phases/13-tools-and-protocols/22-skills-and-agent-sdks (referenced in lines 70‑77 of the learning path definition). This 90‑minute module requires learners to create, install, invoke, verify, and remove a complete skill bundle.

Key competencies include understanding the runtime boundary between host environments and portable contracts. Learners practice using the npx skills add command to fetch remote skill definitions and establish the install-and-verify loop that underpins all subsequent stages.

Stage 2: Skill Discovery and Progressive Disclosure

Advancing to phases/13-tools-and-protocols/24-skill-discovery-and-progressive-disclosure (lines 80‑87), this 105‑minute stage examines how skills advertise capabilities without exposing full implementations. The curriculum covers skill discovery protocols, catalog publication workflows, and activation sequences.

Learners trace the path from initial discovery through branch‑specific resource loading, mastering how agents progressively disclose functionality based on context and permissions rather than broadcasting complete specifications upfront.

Stage 3: Skill Invocation and Routing

Located in phases/13-tools-and-protocols/25-skill-invocation-and-routing (lines 90‑97), this 105‑minute lesson distinguishes between explicit invocation and implicit selection. Learners implement routing logic that handles abstention (when a skill declines to process input) and near‑miss handling (when inputs partially match skill signatures).

This stage emphasizes the decision boundary where the host determines which skill consumes a given request, implementing routing evidence that records why specific skills were selected or bypassed.

Stage 4: Skill Permissions, Sandboxes, and Trust

The security module at phases/13-tools-and-protocols/26-skill-permissions-sandboxes-and-trust (lines 100‑107) allocates 120 minutes to containment strategies. Learners distinguish between instruction sets (what a skill claims to do) and permission prompts (what the host allows).

Critical concepts include sandbox containment for filesystem and network access, plus independent verification mechanisms that validate skill behavior without trusting the skill's self-reported status. This stage establishes the trust boundary essential for executing third-party agent code safely.

Stage 5: Skill Evals, Packaging, and Portability

The final core stage in phases/13-tools-and-protocols/27-skill-evals-packaging-and-portability (lines 116‑123) requires 150 minutes of integration testing. Learners run the release gate process, recording routing and authority evidence for audit trails.

This module covers packaging standards that ensure skills remain portable across host implementations, plus verification of upgrade and uninstall behavior to prevent orphaned resources or privilege escalations during lifecycle transitions.

Optional Capstone: Stateless Tool Ecosystem

For learners completing the core route and Phase 13 lessons 06‑20, the Stateless Tool Ecosystem capstone at phases/13-tools-and-protocols/23-capstone-tool-ecosystem (lines 127‑134) provides a 120‑minute systems‑integration challenge. This optional stage requires synthesizing all five previous stages into a cohesive demonstration where skills operate without maintaining state between invocations, relying entirely on the portable contracts and routing mechanisms established earlier.

Practical Implementation: Code Examples

The learning path expects hands-on interaction with skill bundles. Below are minimal implementations referenced in the curriculum source (lines 58‑65):

Install a complete skill bundle from the repository:

# Quick‑start install command (Stage 1)

npx skills add rohitg00/ai-engineering-from-scratch \
    --skill skill-contract-reviewer --full-depth

Execute explicit skill routing with argument passing:

# Explicit skill invocation (Stage 3)

skill-contract-reviewer \
    --script ./reviewer.py \
    --target /some/project \
    --args "input.txt"

A minimal skill script that validates input and returns structured evidence:

# Simple skill script (used in Stage 1)

import sys, json

def main():
    # primitive validation and choice

    data = json.load(sys.stdin)
    print({"valid": True, "choice": "accept"})
    
if __name__ == "__main__":
    main()

Summary

• Five sequential stages progress from basic bundle creation to secure packaging and verification.
• 90‑ to 150‑minute time commitments per stage accommodate deep hands-on practice with real host environments.
• Source files reside in phases/13-tools-and-protocols/ directories 22, 24, 25, 26, and 27, with route definitions in learning-paths/agent-skills.json.
• Security emphasis in Stage 4 provides sandboxing and trust verification before learners reach packaging and evaluation in Stage 5.
• Optional capstone requires completing prerequisites through Phase 13 lessons 06‑20, testing integration of stateless tool ecosystems.

Frequently Asked Questions

How long does the Agent Skills learning path take to complete?

The five core stages require 570 minutes (9.5 hours) of directed study, with individual stages ranging from 90 to 150 minutes. The optional Stateless Tool Ecosystem capstone adds 120 minutes, bringing the total curriculum to 690 minutes (11.5 hours) for comprehensive completion. These estimates assume learners complete all installation, verification, and routing exercises described in the docs/en.md files.

What prerequisites are required before starting the Agent Skills path?

According to the source curriculum (lines 127‑134), learners should complete Phase 13 lessons 06‑20 before attempting the optional capstone. While the five core stages stand alone, the capstone explicitly requires foundational knowledge from earlier Phase 13 content regarding tool protocols and agent SDKs.

Where are the lesson files located in the repository?

Each stage corresponds to a numbered directory under phases/13-tools-and-protocols/: Stage 1 resides in 22-skills-and-agent-sdks, Stage 2 in 24-skill-discovery-and-progressive-disclosure, Stage 3 in 25-skill-invocation-and-routing, Stage 4 in 26-skill-permissions-sandboxes-and-trust, and Stage 5 in 27-skill-evals-packaging-and-portability. The master route definition lives at learning-paths/agent-skills.json in the repository root.

Does the curriculum cover both explicit and implicit skill invocation?

Yes. Stage 3: Skill Invocation and Routing specifically addresses explicit invocation through direct command calls, implicit selection via host routing logic, abstention patterns when skills decline inputs, and near‑miss handling for partial signature matches. This comprehensive coverage ensures learners understand the full decision matrix hosts employ when delegating tasks to agent skills.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}