You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
"title": "AI Coding Assistants: Operating the Tools",
4
+
"lessonId": "intro",
5
+
"estimatedDuration": "40-50 minutes",
6
+
"learningObjectives": [
7
+
"Understand the mental model: AI agents as CNC machines, not teammates",
8
+
"Learn the three-phase production workflow: Plan, Execute, Validate",
9
+
"Recognize when to delegate to agents vs. write code yourself"
10
+
]
11
+
},
12
+
"slides": [
13
+
{
14
+
"type": "title",
15
+
"title": "AI Coding Assistants: Operating the Tools",
16
+
"subtitle": "Operator training for production AI workflows",
17
+
"content": [],
18
+
"speakerNotes": {
19
+
"talkingPoints": "Welcome. We're here to teach you how to operate AI coding assistants effectively in production. Not theory, not templates. Operator training. The technology works, but most developers hit a frustration wall because they approach AI agents with the wrong mental model.",
20
+
"timing": "1 minute",
21
+
"discussion": "Before we start: Who has used an AI coding assistant? How long before it felt frustrating?",
22
+
"context": "This course was built using the techniques you'll learn here—the entire curriculum was planned, executed, and validated through systematic AI-assisted workflows.",
23
+
"transition": "Let's start with the fundamental problem."
24
+
}
25
+
},
26
+
{
27
+
"type": "concept",
28
+
"title": "The Core Problem",
29
+
"content": [
30
+
"AI agents aren't teammates—they're tools",
31
+
"Most developers treat them like junior devs: wait, fix, iterate",
32
+
"That model breaks at scale: context limits, consistency issues, no judgment",
33
+
"You need to learn to operate them, not manage them",
34
+
"The gap between 'works' and 'production-ready' is huge"
35
+
],
36
+
"speakerNotes": {
37
+
"talkingPoints": "The frustration wall happens because developers approach AI agents wrong. You're used to working with people—giving vague requirements and letting them figure it out. AI agents don't work that way. They need precise, structured input. They don't have judgment. They don't carry context across conversations. You need to be the operator, not the manager.",
38
+
"timing": "2-3 minutes",
39
+
"discussion": "When you've used an AI assistant, what went wrong? Usually it's one of: vague requirements, lost context, code that compiles but doesn't work, or you spent more time fixing than writing.",
40
+
"context": "In production systems, the difference between 'it worked in the prompt' and 'it passes tests in CI' is critical. AI agents can generate code that looks right but fails edge cases, breaks existing behavior, or doesn't scale.",
41
+
"transition": "So how do you operate them correctly? Start with a mental model shift."
42
+
}
43
+
},
44
+
{
45
+
"type": "concept",
46
+
"title": "Reframe: AI as CNC Machine",
47
+
"content": [
48
+
"CNC machines execute precise instructions, not vague ideas",
49
+
"The operator must specify: geometry, materials, tolerances, sequencing",
50
+
"Bad input → bad output, regardless of machine quality",
51
+
"The machine doesn't understand 'close enough' or context",
52
+
"Operator skill is more important than machine capability"
53
+
],
54
+
"speakerNotes": {
55
+
"talkingPoints": "Think of AI agents like CNC machines. A CNC machine is incredibly capable, but you can't say 'make me a gear' and expect it to work. You specify exact dimensions, materials, cutting parameters, toolpath sequence. If your specs are vague or wrong, the machine executes perfectly—but you get garbage. The quality of output depends on operator precision, not machine quality.",
56
+
"timing": "2-3 minutes",
57
+
"discussion": "How is this different from working with a team member? What's the fundamental difference?",
58
+
"context": "This reframe changes everything. Instead of 'how do I get the AI to understand what I mean,' you ask 'how do I specify what I need precisely enough that an agent can execute it.'",
59
+
"transition": "With that mental model, here's the actual production workflow."
60
+
}
61
+
},
62
+
{
63
+
"type": "concept",
64
+
"title": "The Three-Phase Workflow",
65
+
"content": [
66
+
"Plan: Break work into agent-appropriate tasks, research architecture, ground in context",
67
+
"Execute: Craft precise prompts, delegate to specialized agents, run operations in parallel",
68
+
"Validate: Use tests as guardrails, review code critically, require evidence of correctness"
69
+
],
70
+
"speakerNotes": {
71
+
"talkingPoints": "This is the operator workflow. Plan phase: understand the architecture, break work into tasks an agent can handle in one session without forgetting context. Execute phase: give precise instructions, use specialized agents for different tasks, run independent work in parallel. Validate phase: you don't trust the output—you verify it with tests, code review, and explicit checks. This is systematic, not ad-hoc.",
72
+
"timing": "3-4 minutes",
73
+
"discussion": "Which of these phases do you currently skip? Most engineers skip planning and validation, jump straight to execution, then get frustrated when output is wrong.",
74
+
"context": "In production systems at scale, skipping any phase causes problems. No planning = agents waste context on architecture learning. No execution strategy = sequential work that takes 10x longer. No validation = code that breaks tests or existing behavior. All three phases are required.",
75
+
"transition": "Now let's see how this applies in practice. Here's what this course will teach you."
76
+
}
77
+
},
78
+
{
79
+
"type": "concept",
80
+
"title": "What You'll Learn",
81
+
"content": [
82
+
"Module 1: Mental models and how agents actually work",
"Hands-on exercises on real codebases (not toy examples)",
86
+
"Skills that compound: each technique builds on previous ones"
87
+
],
88
+
"speakerNotes": {
89
+
"talkingPoints": "This is structured progression. Module 1 gives you the mental models and internals you need to operate effectively. Module 2 teaches methodology—systematic approaches that work at scale. Module 3 is practical techniques applied to real workflows. Critical: you learn by doing. Reading alone doesn't build operator skills. You'll work through exercises on real codebases, not the examples in the course.",
90
+
"timing": "2 minutes",
91
+
"discussion": "What workflows do you want to improve? Onboarding? Refactoring? Debugging? Knowing your target helps you focus during exercises.",
92
+
"context": "The reason hands-on is mandatory: operator skill is muscle memory. You need to experience what precision in prompting looks like, how to structure research tasks, how to validate output. Passive learning won't give you that.",
93
+
"transition": "Before we start, let's be clear about what this course is NOT."
94
+
}
95
+
},
96
+
{
97
+
"type": "comparison",
98
+
"title": "What This Course Isn't",
99
+
"left": {
100
+
"label": "What You Might Expect",
101
+
"content": [
102
+
"AI theory and internals deep-dives",
103
+
"Prompt templates to copy-paste",
104
+
"Replacement for fundamentals (data structures, system design)",
105
+
"For developers without production experience",
106
+
"Training wheels or hand-holding"
107
+
]
108
+
},
109
+
"right": {
110
+
"label": "What You Actually Get",
111
+
"content": [
112
+
"Just enough internals to operate effectively",
113
+
"Principles that work across tools and domains",
114
+
"Assumes you already know software engineering",
115
+
"3+ years experience is baseline",
116
+
"Direct, coworker-level communication"
117
+
]
118
+
},
119
+
"speakerNotes": {
120
+
"talkingPoints": "Be honest about what this course is. It's not theory. It's not templates. It assumes you already know how to engineer software—data structures, design patterns, system design. We're teaching you operator skills for AI agents, not fundamentals. If you're early-career, start with production experience first. This course assumes you've debugged production bugs, refactored large systems, onboarded to unfamiliar codebases. We're building on that.",
121
+
"timing": "2 minutes",
122
+
"discussion": "If you're early-career or unfamiliar with these concepts, ask now. We can point you to resources, but this course won't cover basics.",
123
+
"context": "The right prerequisites matter. Teaching operator skills to someone without production context would fail. The techniques don't make sense without understanding why code quality, testing, and architecture matter.",
124
+
"transition": "Assuming you're ready, here's what you'll gain from completing this course."
125
+
}
126
+
},
127
+
{
128
+
"type": "concept",
129
+
"title": "What You'll Be Able to Do",
130
+
"content": [
131
+
"Onboard to unfamiliar codebases 5-10x faster using agentic research",
132
+
"Refactor complex features reliably with test-driven validation",
133
+
"Debug production issues by delegating analysis to agents",
134
+
"Review code systematically with AI assistance and critical judgment",
135
+
"Know when to use agents and when to write code yourself"
136
+
],
137
+
"speakerNotes": {
138
+
"talkingPoints": "These aren't hypothetical. These are workflows you can do after this course. Onboarding a new codebase usually takes weeks—with agents, days. Refactoring risky code becomes possible when you have tests and agents working in parallel. Debugging gets faster when agents can analyze logs while you think strategically. Code review becomes scalable when agents find patterns while you focus on judgment. Most importantly: you learn judgment. When to delegate, when to code, when to stop and think.",
139
+
"timing": "2-3 minutes",
140
+
"discussion": "Which of these would impact your work most? Focus on that during exercises.",
141
+
"context": "The scaling benefit comes from judgment. Beginners try to use agents for everything. Experts know when not to. That judgment is what separates 10x from frustrated.",
142
+
"transition": "Now let's make sure you have everything you need to succeed."
143
+
}
144
+
},
145
+
{
146
+
"type": "concept",
147
+
"title": "Prerequisites & Setup",
148
+
"content": [
149
+
"Experience: 3+ years professional software engineering",
150
+
"Tools: Access to a CLI coding agent (Claude Code, Copilot, etc.)",
151
+
"Mindset: Willingness to abandon 'AI as teammate' thinking",
152
+
"Environment: Real codebase to practice on (not course examples)",
153
+
"Time: Hands-on exercises are mandatory, not optional"
154
+
],
155
+
"speakerNotes": {
156
+
"talkingPoints": "Check your prerequisites. Experience matters because the techniques build on production thinking. You need a CLI agent—the techniques work with Claude Code, Copilot CLI, or others, but you need direct command-line access for the workflows we teach. Mindset is critical: you need to unlearn collaborative patterns and adopt tooling patterns. Real codebases: exercises on toy code don't build skills. Use your actual codebase or a real open-source project. Time: this isn't something you watch. Hands-on work is mandatory.",
157
+
"timing": "2 minutes",
158
+
"discussion": "Do you have a real codebase to practice on? If not, pick one now. This course only works with real code.",
159
+
"context": "We'll provide examples, but the learning happens when you apply these to code that matters. Toy examples don't have the complexity that forces you to learn the techniques.",
160
+
"transition": "One more thing before we start: let's talk about how this course was built."
161
+
}
162
+
},
163
+
{
164
+
"type": "concept",
165
+
"title": "This Course Practices What It Teaches",
166
+
"content": [
167
+
"All content planned and structured using agent-assisted techniques",
168
+
"Code examples generated and validated through agentic workflows",
169
+
"Podcast versions created using Claude and Gemini APIs—multi-speaker audio",
170
+
"Voices (Alex and Sam) are AI-generated, as is their script",
171
+
"Process followed the exact methodology you'll learn here"
172
+
],
173
+
"speakerNotes": {
174
+
"talkingPoints": "This isn't marketing. It's validation. The curriculum itself was built using the workflow you'll learn. We planned the structure with agent assistance. We generated examples and validated them. We created podcast versions using AI speech synthesis and script generation. If these techniques can produce production-grade training material on their own application, they're robust. This tells you: the methods work. Not in theory. In practice, on real output.",
175
+
"timing": "2 minutes",
176
+
"discussion": "Does knowing the course was built this way change how you approach it? Does it make you more skeptical or more confident?",
177
+
"context": "Transparency matters. We're not hiding that AI was used. We're explicit about it. That's the mindset we teach: transparent about AI involvement, critical about output, rigorous about validation.",
178
+
"transition": "You're ready. Let's get started."
179
+
}
180
+
},
181
+
{
182
+
"type": "takeaway",
183
+
"title": "Key Takeaways: Getting Started",
184
+
"content": [
185
+
"AI agents are CNC machines—precision in, garbage out, no judgment built in",
186
+
"Production workflow: Plan → Execute → Validate (not ad-hoc prompting)",
187
+
"Operator skill matters more than tool quality—you are the limiting factor",
188
+
"Hands-on practice on real code is mandatory, not optional",
189
+
"Success depends on judgment: knowing when to use agents vs. write code yourself"
190
+
],
191
+
"speakerNotes": {
192
+
"talkingPoints": "Remember these five points as we move through the course. The mental model shift (CNC machine, not teammate) changes how you approach every interaction. The three-phase workflow is systematic—you'll use it repeatedly. Operator skill is the multiplier. And judgment—knowing when to delegate and when to stop and think—is what separates experts from frustrated users. This course teaches both skill and judgment.",
193
+
"timing": "2 minutes",
194
+
"discussion": "Which of these resonates most with your experience? Which do you think will be hardest to implement?",
195
+
"context": "These aren't abstract principles. They directly address the frustration points most engineers hit: vague prompts, lost context, code that doesn't work, inefficient iteration cycles. The workflow solves all of these.",
196
+
"transition": "Ready to move to Module 1: Understanding the Tools. Let's start with how AI agents actually work."
0 commit comments