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

> Explore the 5 key stages of the Agent Skills learning path from rohitg00/ai-engineering-from-scratch. Master runtime boundaries, skill discovery, invocation, permissions, and evals.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: tutorial
- Published: 2026-09-02

---

**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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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:

```bash

# 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:

```bash

# 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:

```python

# 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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/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.