Workshop — 5 Weeks · Saturdays · 2 Hours
AI/LLM Skills Workshop
A progressive, hands-on curriculum for software developers — from foundational concepts to spec-driven agent development. 11 sessions across 5 Saturdays.
What This Is
From token costs to executable specs — in five sessions
Most developers use AI tools every day but haven't built a mental model of how they actually work. That gap shows up as unpredictable results, expensive mistakes, and a ceiling on what they can do with AI.
This workshop closes that gap systematically. Each session builds on the last — from understanding what a token costs to writing specifications that an agent can execute reliably with no gaps left to inference.
The goal isn't to make you faster at prompting. It's to bring you to the point where you adopt a spec-driven development mindset with AI agents — where clarity of intent drives everything downstream.
Format
Small cohort — learn alongside other developers. 2 hours every Saturday for 5 weeks. Hands-on throughout: every session involves live demos, real code, and work you do during the session.
Who It's For
Software developers who use AI tools regularly but want to go deeper — past the surface-level prompting into real fluency with LLMs, agents, and the patterns that make them reliable.
What You Bring
A laptop, an active Claude or ChatGPT account, and a real codebase you're working on. Sessions are more valuable when grounded in your actual work.
Advanced workshop planned. Participants who complete this cohort get priority access to the advanced track — covering quantitative evals, multi-agent orchestration, and production-grade agentic workflows.
The Schedule
5 Saturdays. 11 Sessions.
Each week has a theme. Each session has a takeaway you can apply before the next one.
How LLMs Actually Work
Foundations
Tokens → Context Window
Understand how LLMs read and process text as tokens, and how the context window defines the boundaries of what a model can see. Every token costs money — you'll watch it happen in real time.
The mental model everything else builds on.
Prompt Engineering
Learn the four failure modes in a poorly written prompt and how to diagnose exactly why a prompt failed before reaching for a fix. Prompt engineering is debugging, not guessing.
A diagnostic framework you'll apply to every prompt you write.
Modes / System Prompt
Understand how system prompts set the operating context for a model. You'll write a system prompt from scratch and see what changes — and what doesn't — when it's vague versus precise.
Replace the model's defaults with something that works for you.
Model Selection
Learn the tradeoffs between reasoning models, fast models, and multimodal models across capability, cost, and latency. You'll run the same complex prompt across four configurations and compare.
The judgment to pick the right model — not just the most capable one.
Reading Output Critically
Evaluation & Rules
Evaluation
Build the instinct to read LLM output critically. You'll apply a three-point review protocol — SID, Patterns, Simplicity — to a realistic code sample and find what slipped through.
A structured protocol for catching what you'd normally skim and ship.
Basic Rules
Distinguish between rules that actually change model behavior and rules that only sound correct. You'll sort 10 real rules — then write your own from the failures you found in session 5.
A working rulebook built from real failure modes, ready to use immediately.
Making Behavior Persistent
Agent Configuration
AGENTS.md / CLAUDE.md
Learn how to define agent behavior in a persistent rules file the agent reads automatically. You'll adapt a real AGENTS.md to your project and extend it with rules that exist only in your head right now.
Your rules live in the project — not in a prompt you have to remember to paste.
Scoped Rules
Go beyond global rules to define context-specific behavior. You'll sort every rule you've written into the right scope, build a routing table, and verify that the agent loads only what's relevant.
A leaner AGENTS.md, scoped rule files, and a token budget that thanks you.
Tools, Chains, and Harnesses
Agentic Systems
Tool Use / MCP + Function Calling
Understand how models interact with external tools through function calling and MCP. You'll build a multi-tool chain connecting GitHub and Slack, run it, then deliberately break it to understand partial failure.
The design principles for tool chains that are safe to run in production.
Harness Engineering
Every mistake the agent makes is a signal that something in the environment is missing or unenforced. You'll audit your own repository against three pillars — context engineering, architectural constraints, and garbage collection.
A harness that makes agent mistakes structurally impossible, not just less likely.
The Capstone Skill
Spec-Driven Development
Writing Specs for Agents
Learn to write precise, unambiguous specifications that an agent can execute reliably. You'll hunt gaps in a deliberately flawed spec, rewrite it with exhaustive Given → When → Then criteria, and produce a complete spec for a real task in your own project.
The mindset shift that changes how you work with AI permanently.
Retrospective & Next Steps
Look back at the full arc — from tokens to specs — and take stock of what's changed in how you work. We'll surface the highest-leverage next steps for each participant and map a path to the advanced workshop.
A clear picture of where you are and what to build next.
What You'll Build
Skills that compound
Every session connects to the next. By the end, these aren't concepts you've heard about — they're habits you've practiced.
Genuine AI Fluency
Not surface familiarity — a mental model of how LLMs actually work, what they cost, and where they fail.
A Diagnostic Instinct
When a prompt fails or output looks wrong, you'll know why — and fix the right thing, not just retry.
A Working Rulebook
Rules that come from real failures in your own work, encoded in an AGENTS.md that lives in your project.
Spec-Driven Thinking
The capstone skill: writing specs an agent can execute reliably, with no gaps left to inference.
The Arc
Everything builds on everything
Understanding
- You learn what tokens cost and how they drain
- You develop a diagnostic framework for prompt failures
- You see how system prompts shape everything downstream
- You pick the right model for the right task
- You evaluate LLM output before acting on it
Control
- You write rules that actually change model behavior
- Your rules live in the project — not in your head
- Context-specific behavior loads only when needed
Systems
- You design multi-step tool chains safely
- You audit your own repo and close the highest-leverage gaps
Mastery
- You write specs an agent can execute with zero gaps left to inference
Ready to build real AI fluency?
Cohorts are small by design. Book a free discovery call to talk through whether this workshop is the right fit for where you are right now.