AI builds the feature

  ╱╲╱╲╱╲╱╲
 ╔══════════╗
 ║  ◈    ◈  ║
 ║     ┴    ║
 ║  ╰────╯  ║
 ╚═╦══════╦═╝
   10110100
    011 10
     1 0

This module reveals the foundational architecture of the entire course. Artificial intelligence fundamentally amplifies human intent. It systematically absorbs iterative labor, granting human intelligence the space to question paradigms and architect new systems. However, a system only possesses as much power as the structures that mold it. We will examine the repository you are currently reading to understand these specific molds. The precise rules, skills, and knowledge files within this codebase allowed an agentic system to construct these six modules while remaining entirely subordinate to human direction.

the agentic loop

An agentic coding session represents the culmination of modules 01 through 05 operating simultaneously. A grounded model navigates a repository, follows explicit instructions, and undergoes rigorous verification before any code ships. The inner loop consists of a continuous cycle: plan, edit, run, verify, and commit. The verification stage requires genuine execution. You must intentionally trigger errors to map failure paths rather than merely relying on a successful compilation.

Because context windows possess strict limitations, complex features must survive as permanent artifacts outside the active session. A structured plan carries human intent across multiple sittings, acting as a durable memory system for the build process.

Observe a single feature traveling through this complete loop:

four foundational molds

An agent requires specific instruments to navigate a repository successfully. Choosing the correct instrument requires understanding its computational cost and its operational lifespan within the system.

• The rules file (CLAUDE.md or AGENTS.md): The system injects this file into the context window at the beginning of every session. Because it occupies permanent space, it must contain only absolute truths. It holds the core build command, the foundational workflow, and the non-negotiable boundaries of the project.
• Skills: Procedural capabilities equipped with explicit triggers. The system loads only the name and description into the active context, retrieving the full execution body strictly upon invocation.
• Knowledge docs: Present-tense records detailing the current state of each subsystem. These documents evolve and commit simultaneously with the code they describe.
• Plan artifacts: A comprehensive specification of a single feature. This document details phases and necessary judgment calls, requiring human review before any code generation begins.

Evaluate and sort these situations yourself:

Skills require strict grammatical discipline because a skill relies entirely on its trigger. Name every skill using an active verb, such as knowledge-first, sync-docs, or security-final-check. Furthermore, write the description as the explicit trigger condition, stating precisely what the skill accomplishes and when the system must invoke it:

---
name: sync-docs
description: Update the knowledge/ documentation to match the code
  AFTER making any change, including new features, refactors, and convention
  changes. Use immediately before committing.
---

This description functions as the API the agent reads to determine its actions. The discovery mechanism operates uniformly across platforms. Claude Code automatically loads the rules file, surfaces each skill’s frontmatter, and pulls the body only upon explicit invocation. MCP servers extend this capability, advertising tools as precise name-and-parameter schemas. Google Antigravity reads rules and workflow files identically. It operates across the editor, terminal, and browser while externalizing task lists and implementation plans as reviewable artifacts.

The governing law remains constant across all tools: agents discover capability by matching the human task against authored descriptions. You must write these descriptions with absolute precision.

the compounding flywheel

The repository itself serves as the ultimate memory system. Knowledge documents distill the understanding of each feature into the project’s permanent record. A stale document represents a fabricated memory carrying the full authority of the codebase; therefore, documentation updates must accompany the code they describe.

The plan artifact serves as the mandatory confirmation gate. It demands a specification first, forces judgment calls into the open, and requires explicit human approval before the build begins. This course practiced these exact mechanisms upon itself. Every module you have read shipped as a single commit gated by knowledge-first, verified in a live browser, synchronized with documentation, and cleared through a security check. A human reviewed the specific judgment calls and authorized the progression.

Equip yourself with the materials. Download the complete set of fill-in templates representing the four foundational molds: agentic-coding-starter.md. To study the original architecture, review this site’s CLAUDE.md and .claude/skills/ directories, alongside the knowledge conventions provided in the curriculum’s other downloads.

We have constructed six distinct rooms. Ground the model to prevent fabrication. Define the voice to ensure consistency. Gate the output to enforce quality. Maintain the record to guarantee continuity. Separate observation from judgment to protect the truth. Supply the overarching standards, provide the definitive approval, and initiate the loop. The machine supplies the velocity; the standards and the final authority belong entirely to you. Mark this module complete to finish your work within the syllabus.