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. Five Saturdays, each a two-hour session. $899 per participant.
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
Two hours every Saturday. Five weeks.
Sessions that build on each other.
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.
Tell the Model What It Can and Can't Do
Evaluation & Guidance
Output 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.
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.
AGENTS.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.
Skills
Skills are rules that load only when they're relevant. You'll write skills that trigger on specific contexts in your work — so the agent has guidance when it needs it, without overwhelming it with rules that don't apply.
How to define skills that guide agent behavior in specific contexts without overwhelming it with rules that don't apply.
Constraining the Agent Makes It Perform Better, Not Worse
Constraints & Harnesses
The Paradigm Shift
The engineer's job changes when agents do the coding. You'll internalize the three foundational principles of harness engineering — and why every mistake the agent makes is an engineering problem, not a prompting problem.
A fundamentally different orientation toward AI-assisted development.
Context Engineering
The agent sees only the repository. You'll learn how to structure your docs/ directory as a machine-readable knowledge base — design docs, architecture maps, quality grades, and execution plans — so the agent always has what it needs.
A repository the agent can navigate without asking you for context.
Architectural Constraints
A rule the agent can ignore isn't a rule — it's a suggestion. You'll learn how to enforce architectural boundaries mechanically through linters, structural tests, and CI gates so violations are impossible, not just discouraged.
At least one architectural rule that is now enforced by the build, not by hope.
Garbage Collection & Full Audit
Harnesses rot. Docs go stale, architecture maps diverge from reality, and rules that made sense six months ago no longer apply. You'll build a garbage collection strategy and run a full three-pillar audit of your own repository.
A harness that stays accurate — and a clear list of what to fix next.
Tools, Chains, and Harnesses
Agentic Systems
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.
Orchestration and Sub-Agents
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.
The Capstone Skill
Demos & Retrospective
Project Demo
This is a chance to show off what you've built. You'll demo your project with the new skills you've developed — and talk through how the skills connect in real time as you work through a task.
A clear picture of how the skills you've built connect and compound in real work.
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.