Speed without discipline is not engineering.

AI coding agents make development 10× faster. Without process, that speed produces broken code, lost context, and runaway cost.

Your Foundation for Agentic Engineering

Four modules move from the discipline to the machinery — so you can use coding agents deliberately, not by instinct.

Why This Course Exists

Problem   “Vibe coding” — asking AI to write code without process — produces unmaintainable, untested code that breaks in production.

Who This Course Is For

What Is an Agent?

Problem   One-shot prompts fail on complex tasks. Every LLM call has limited context, no planning, and no verification.

Concept   An Agent is an intelligent orchestrator that decomposes work and decides what to do next.

What Is a Large Language Model?

How LLMs Power Agents

The LLM is the brain. The agent is the body.

The Agent as Orchestrator

From single-intent assistants to purpose-based orchestrators that coordinate parallel subagents.

The Problem With “Vibe Coding”

The 5-Phase Agentic Framework

Each phase has one owner and produces one deliverable. No phase is optional.

Three Scenarios, One Framework

The same 5-phase pipeline — different entry points. The discipline never changes.

What Did We Learn?

Claude Code: Your Agentic CLI

Problem  The 5-phase framework needs a tool — one that reads codebases, runs tests, and loads skills.

Concept  Claude Code is Anthropic’s official CLI — your terminal interface to agentic engineering.

The .claude/ Directory

Problem  Skills, hooks, settings, rules — scattered. Without the map, you waste hours searching.

A Real ~/.claude/ — Config, Skills & Agents

Demo  What actually lives in your global config directory — the pieces you configure and invoke directly.

A Real ~/.claude/ — Memory, History & More

Demo  Directories Claude manages itself — memory, audit trails, costs, and custom providers.

How ~/.claude/projects/ Works

Demo  Every project you’ve ever worked on gets its own directory — named after the path on your machine.

The Root ~/.claude.json

Demo  Claude Code’s global runtime state — usage history, per-project snapshots, and last-session metrics.

The Status Line — Your Live Dashboard

Concept  Every number visible the moment Claude Code opens — and every one of them is customizable.

Skills: Automate Your Workflows

Problem  Every session starts from zero. You re-explain conventions — every single time.

Solution  Skills = markdown in .claude/skills/, loaded on demand via slash command.

Dissecting a Skill

Skills aren’t only files you write — they ship with the CLI, arrive via plugins, or live in your repo. Same anatomy, three sources.

Built-in Skills: Natural Language Invocation

You don’t have to type /init to trigger the init skill — ask in plain language and Claude’s LLM matching does the rest.

Built-in Agents: Explore Before You Build

Two read-only agents shipped inside Claude Code — and the targets your skills can delegate to via context: fork.

Demo: Automation Recommender

A read-only skill that analyzes your codebase and surfaces the top 1–2 automations across all five extension points — with why, not just what.

Demo: Recommendation → Skill → Output

The recommender suggested a release-notes skill for claude-lens. We built it on the spot and ran it — here’s what happened.

Demo: Let Bash Do the Work

Three versions of the same commit skill — each one moves more work out of the LLM and into bash. The tokens follow.

Dynamic Context Injection

Prefix a line with ! — the command runs before Claude reads the skill; its output replaces the line. Cheap, fast, live state.

Skill Frontmatter — The Top of the File

Every skill is a markdown file. The YAML between the --- markers configures how it loads, what tools it can call, and when Claude can auto-invoke it.

Skill Frontmatter — Beyond the Basics

The fields that handle the long tail: arguments, paths, lifecycle, sharing, and control. Most skills use only a subset — pick what your workflow actually needs.

What Is a Token?

Before the model reads anything, your text is chopped into tokens. The model never sees letters or words — only tokens.

What’s in the Context Window

The context window is the model’s working memory for one request — finite, about 200K tokens for Sonnet. And most of it is loaded before you type a single word.

The Server Remembers Nothing

Every message, Claude Code packages the entire context into one payload and ships it. The server holds nothing between calls. The model is a pure function of the text you send.

The Loop: How Tools Run

The model can’t run anything. It returns text, or a request to use a tool. Claude Code runs the tool, appends the result, and sends the whole thing back. Repeat.

Why Sessions Get Expensive

Problem  Every turn re-sends a growing context. You pay input tokens for the whole window — again and again. Twenty turns deep, you’re re-billing the same 50K tokens twenty times.

Why It’s Expensive: Tokenize, Prefill, Decode

When you hit Enter, the server doesn’t just “read and reply.” Three stages run in sequence — and the middle one is where almost all the cost lives.

Live: Prefill vs. Decode

Same machine — a Mac Mini M4 Pro running a local LLM via oMLX. Two screenshots, seconds apart. First the prefill pipeline ingests the prompt. Then generation begins.

Stage ② · Prefill

1 PP (1 req in prefill) · 14.9K-token prompt ingested at 107.8 tok/s

Stage ③ · Decode (Generate)

Generating… · emitting tokens at 16.0 tok/s · cache meter visible top-right

KV Cache: Compute Once, Reuse

Solution 1  To emit each new token, attention must look at the Key and Value of every earlier token. So compute each token’s K/V once, store them, and reuse — instead of re-deriving the whole history at every step.

Inside the Lookup: How Attention Picks

Previously we called attention a soft dictionary lookup. Here’s the actual mechanic — three steps that turn the current token’s Query into one blended answer. Worked on a real sentence.

Where the KV Cache Lives

The cache is not inside the model’s weights. Inside the inference server there are three distinct regions — and your tokens’ K/V only ever land in one of them.

The Boxes, Live in oMLX

The three boxes aren’t an abstraction — the inference server exposes each one as its own panel. Same oMLX dashboard running Qwen locally on a Mac Mini. Each panel is one box.

① Weights → “Active Models”

Qwen3.5-9B-OptiQ-4bit
~7.12 GB est · panel total 29.4 GB

② KV Store → “Runtime Cache”

Memory 16.1 / 32 GB
146 entries · 0 evictions

③ Forward Pass → “Working Buffers”

Activations + workspace
~6 GB — the gap between 7.12 GB weights and 29.4 GB total

What Caching Actually Skips

Back to the three stages from 21E1. Two of them get confused — and only one is ever cached. The trap: thinking “tokens are already computed, so what’s left to cache?”

Prompt Caching: Same Store, Kept Warm

Solution 2  Prompt caching is the same KV store — the server just chooses not to free it. It keeps the prefix’s K/V alive across requests, so the next turn loads them instead of re-prefilling. You still send everything every turn; the server stays stateless.

What Is Your Stable Prefix?

Prompt caching works because your context has a predictable structure. The front never changes; only the tail does — and knowing this changes where you should write your instructions.

Live: Without Cache

I ran the same prompt through Claude Code with cache disabled. Left: oMLX shows the serving mechanics. Right: Claude Code shows what you pay. Every turn recomputed from scratch.

oMLX Dashboard · Session Totals · Cache Disabled

224,545 prefill tokens · 0 cached · 0.0% efficiency

Session Cost

Time Elapsed

10m 39s

Cost

$1.44

Cache Efficiency

0%

Live: With Cache

Same prompt. Same model. Same machine. The only difference: cache is enabled. Watch the prefix stay warm.

oMLX Dashboard · Session Totals · Cache Enabled

155,505 prefill tokens · 108,544 cached · 69.8% efficiency

Session Cost

Time Elapsed

3m 13s

Cost

$0.39

Cache Efficiency

69.8%

Spend Fewer Tokens, Do More

Everything so far was the machine. Here’s how you work it without bleeding tokens — habits that fall straight out of how context and caching actually behave.