AI Engineering from Scratch with Claude Code: A Complete Integration Guide for AI Coding Assistants

AI Engineering from Scratch distributes its curriculum as Claude Code-compatible skills, letting AI coding assistants such as Claude Code, Codex, and Cursor execute slash commands that fetch lesson code, run tests, and ship production-ready artefacts without any custom integration code.

The rohitg00/ai-engineering-from-scratch repository is an interactive, agent-native curriculum built around executable artefacts rather than static documentation. Every lesson ships as a SKILL.md artefact that follows a host-agnostic plain-text contract, enabling the repository to function as a plug-and-play learning platform inside Claude Code. Because the curriculum exposes prompts, agents, and Model Context Protocol (MCP) servers through this standardised skill interface, AI Engineering from Scratch turns your AI coding assistant into an interactive tutor that builds, validates, and exports code alongside you.

How the Claude Code Skill Format Powers the Curriculum

The integration rests on the Claude Code-compatible SKILL format, a plain-text contract that any compatible host can ingest and execute. This design mirrors the Claude Code Agent SDK architecture: a system prompt describing tool definitions, a tool surface that maps slash commands to skill invocations, and a session persistence layer that stores long-term state in CLAUDE.md-style files. By centralising agent behaviour in AGENTS.md, the repository provides hooks, contracts, and priority rules that Claude Code, Codex, and other agents consult before executing any lesson step.

Because the skill layer is host-agnostic, the same SKILL.md files work across Claude Code, Codex, Cursor, and any other assistant that understands the skill interface. This makes AI Engineering from Scratch a universal tutoring engine rather than a single-platform tool.

Installing AI Engineering from Scratch in Claude Code

Registration happens through a single command. The host automatically discovers and registers every SKILL.md found in the repository, creating the corresponding slash commands in your Claude Code session.

# Install the curriculum's skills into a Claude Code-compatible host

npx skills add rohitg00/ai-engineering-from-scratch

Once installed, Claude Code recognises the curriculum as a first-class skill provider and loads the lesson definitions into its tool surface. No additional configuration or custom code is required on the user side.

Core Slash Commands for Interactive Learning

Each skill defines its host-specific invocation in the skill header, enabling Claude Code to route commands to the correct lesson runner. The curriculum exposes several entry points:

• /start-learning – Registered by skills/start-learning/SKILL.md, this command launches the placement tutor and begins the curriculum flow.
• /learn <path> – Implemented in skills/learn/SKILL.md, this command drives the lesson-by-lesson tutoring loop: fetching narrative docs, building code, running tests, and recording progress.
• /learn-mcp – Defined in skills/learn-mcp/SKILL.md, this command opens the dedicated Model Context Protocol track.
• /learn-agent-skills – Provides a dedicated path for advanced agent engineering concepts.
• /check-understanding 13 – Validates comprehension by referencing the local learning file and checking a specific lesson index.

For example, to jump directly to the agent-loop fundamentals, you would invoke:

# In Claude Code, invoke a specific lesson path:

#    /learn 14-agent-engineering/01-the-agent-loop

Inside the Lesson Execution Flow

When you issue a slash command, Claude Code reads the associated SKILL.md and begins a structured execution loop. The host streams the lesson narrative from a file such as phases/14-agent-engineering/01-the-agent-loop/docs/en.md, compiles the matching implementation in phases/14-agent-engineering/01-the-agent-loop/code/agent_loop.py, and validates the output against the lesson's test suite.

Progress is recorded in a local learning file such as LEARNING.md, giving the session persistence across restarts. If the lesson generates reusable components, they are written to the outputs/ directory for direct import into other projects. This flow means Claude Code is not merely displaying text—it is acting as a build-and-test runner that ships production-ready artefacts.

Key Source Files That Enable the Integration

The following files form the backbone of the Claude Code integration:

• skills/start-learning/SKILL.md – Registers the /start-learning slash command and defines the placement tutor behaviour.
• skills/learn/SKILL.md – Implements the lesson-by-lesson tutoring loop that fetches, builds, tests, and records progress.
• skills/learn-mcp/SKILL.md – Exposes the /learn-mcp command for the Model Context Protocol track.
• AGENTS.md – Serves as the repository-wide instruction file that Claude Code, Codex, and other agents consult for hooks, contracts, and priority rules.
• phases/14-agent-engineering/01-the-agent-loop/code/agent_loop.py – Contains the runnable ReAct-style loop that Claude Code compiles and tests during the lesson.

Reusing Generated Artefacts in Your Projects

After a lesson finishes, the generated artefacts are stored under outputs/ and can be imported directly into a Claude Code project. For instance, completing the agent-engineering track produces a debug-agent prompt and reusable agent implementations.

# Example of a generated artefact (agent loop) you can copy

def run(query, tools):
    history = [user(query)]
    for step in range(MAX_STEPS):
        msg = llm(history)
        if msg.tool_calls:
            for call in msg.tool_calls:
                result = tools[call.name](**call.args)
                history.append(tool_result(call.id, result))
            continue
        return msg.content
    raise StepLimitExceeded

You can inspect shipped prompts and agents immediately:

# After completing a lesson, inspect the generated prompt:

cat outputs/prompts/prompt-debug-agent.md

The outputs/agents/ directory holds the final shipped agents, while outputs/prompts/ stores the associated system prompts, making it trivial to promote lesson code into production tooling.

Summary

• AI Engineering from Scratch uses the Claude Code-compatible SKILL format to expose lessons as executable artefacts.
• Installing the curriculum requires a single command: npx skills add rohitg00/ai-engineering-from-scratch.
• Slash commands such as /start-learning, /learn, and /learn-mcp trigger structured lesson flows that stream docs, build code, run tests, and record progress.
• Key integration files include skills/learn/SKILL.md, skills/learn-mcp/SKILL.md, and AGENTS.md, which together align the repository with the Claude Code Agent SDK.
• Completed lessons generate reusable artefacts under outputs/ that can be imported directly into Claude Code projects.

Frequently Asked Questions

Can I use AI Engineering from Scratch with assistants other than Claude Code?

Yes. The curriculum is host-agnostic. Because the skills follow a plain-text SKILL.md contract, any AI coding assistant that supports the Claude Code skill interface—including Codex, Cursor, and OpenCode—can ingest and execute the same lessons without modification.

What happens when I run a slash command like /learn in Claude Code?

Claude Code reads the SKILL.md for that command, streams the lesson narrative from phases/.../docs/en.md, builds the code in phases/.../code/, runs the test suite, and records your progress in a local file such as LEARNING.md. If the lesson passes, any generated prompts or agents are written to outputs/.

Where does the curriculum store the code and prompts generated during a lesson?

Completed artefacts are placed under the outputs/ directory. For example, agent implementations land in outputs/agents/, while prompts are saved to outputs/prompts/prompt-debug-agent.md. These files can be copied or imported directly into other Claude Code projects.

Do I need to write custom code to connect AI Engineering from Scratch to Claude Code?

No. The integration is plug-and-play. The repository ships with skill definitions in skills/start-learning/SKILL.md, skills/learn/SKILL.md, and skills/learn-mcp/SKILL.md that Claude Code discovers automatically after you run the install command. The repository-wide AGENTS.md file provides the remaining hooks and contracts.

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