Fingers on Keys
Day 21. Week 5. Wall-to-wall lecture. The instructor knew it before we did.
The Review That Didn't Feel Like a Review
Week five is the "we're going back to basics" week. Programming fundamentals. We started the morning with variable declaration.
And I'm sitting there thinking — okay, we've been doing this for a month. We've built apps. We've grinded algorithms. We know what a variable is. This is going to be a quick flyover and we'll get to the interesting part.
That's not what happened.
People had questions. Real questions. Not "I'm confused about this edge case" questions — foundational ones. And I'm watching this and I'm genuinely surprised, but then again, maybe I shouldn't be. Because when you're building things with AI assist for four straight weeks, the AI handles a lot of the syntax for you. You're thinking in logic, not in mechanics. So the mechanics can sit unexamined for longer than they should.
That's the thing about review. It only feels like review if you actually already know it. For a lot of people in that room, it wasn't review — it was the first time they'd been forced to sit with the raw syntax without scaffolding.
I get it. I've been there.
What I Was Doing Instead
I wasn't entirely following along. The early stuff I knew cold, so I was working through FreeCodeCamp on my own — which is the supplementary grind I've been running for a few weeks now.
FreeCodeCamp works for me because I can read at my pace, try the code immediately, see if it breaks, figure out why it broke. That feedback loop — read, type, run, fail, adjust — is how I learn anything. It's how I've learned everything I know about coding since I started five years ago. You have to put your hands on it. There is no shortcut around this.
That's been the advantage of FreeCodeCamp over the lecture format for me: I control the pace, and I always have keys under my fingers.
The more I'm immersed in the language — reading it, writing it, watching it break and fixing it — the faster the syntax becomes automatic. That's what I'm chasing. Not understanding in the abstract. Recall. Muscle memory. The ability to reach for the right construct without stopping to think about whether it needs square brackets or curly braces.
It's Either On or Off
By afternoon, we'd gone from variable assignment all the way through maps, filters, dictionaries, and a handful of more advanced methods. JavaScript and Python, simultaneously, back to back. The twin snake.
And I started feeling it.
I had a moment during the afternoon algorithm where my code was logically correct. The structure was right. The approach made sense. But it wasn't working. Francisco had to point out the issueduring the live — I was using the wrong bracket. Not a conceptual error. A mechanical one. The kind of thing you only drill out by repetition.
That's the ruthlessness of code. It doesn't grade on a curve. You can get ninety percent of a problem right and get zero output. Unlike a foreign language, where someone can read your broken French and piece together what you meant because language has tolerance for ambiguity — code doesn't have that. Wrong syntax and the whole thing sits there, silent. It's either on or it's off. No partial credit.
The only way to get to a place where that stops happening is to use these methods constantly. See them enough times that you don't have to remember the rules — you just know.
And you don't get that from watching a lecture.
I Feel for the Instructors
The instructor knew today was going to be rough. You could tell. As a former teacher — I taught math, remotely, to ninth graders — I know the feeling of walking into a class aware that the material is going to be a slog. You feel it before the students do. And then the silence comes, and you can't tell what the silence means.
Online silence is the hardest part. Is that silence because people genuinely don't know? Because they're zoned out? Or because they're trying so hard to keep up that they haven't even processed the question you asked yet?
Today I watched classmates get called on who clearly weren't unengaged — they were buried. Typing as fast as they could, trying to keep pace, and then their name gets called and they surface like they've been underwater. Not because they weren't paying attention. Because the pace didn't give them room to breathe.
And you can't just shout an answer in a Zoom classroom. You have to click the raise hand button, find your mic, unmute, find your place in the thread of conversation. The friction alone costs you four seconds that you don't have.
The Fix I'd Try
Here's what I'd do differently if I were running a day like this.
Use AI, but not the way we've been using it. Don't use it to help students build things — use it to pre-build a simple dummy app. Something small. A game with no graphics. A basic form that does one thing. Something so simple the AI can't possibly mess it up.
Then tell the students: don't think about the logic. Don't try to understand it yet. Just copy the code. Muscle memory first. Get your fingers on the keys and type it out.
Every ten or fifteen minutes, stop. Go through a block together. Open the AI, or just explain it yourself: this is what this specific chunk is doing inside this specific app. Not "here's what a dictionary is" in the abstract — but "here's what this dictionary is doing right now, in this game, on this line."
Two things happen:
First, the pace problem goes away. There's no race. Students are copying, not transcribing a moving target. They get fingers on keys, which is the only thing that matters.
Second, the context problem goes away. It's not an abstract CodeWars problem or a two-line demo. It's a real thing that runs. You can see the method doing something in an environment that makes sense.
Then you build in buffer. Because some people will type the code exactly right and still have no idea why the semicolon lives there. Some people's app won't even run because they've got a bracket wrong. That's fine — that's the lesson. That's where the questions are.
Four and a half hours of lecture, almost no time to type — that's the other version of this day. I'm not criticizing anyone. I've been in that position. But I'm confident that sixty minutes of copying a simple working app would have produced more lasting retention than the wall-to-wall version we ran today.
White Knuckling It
Look — we were warned. Last week they told us this week would be heavy on fundamentals. I knew going in. So I'm not complaining about the plan. I'm just noting what I felt today, which is what I imagine the rest of the class felt: you white-knuckle it through five hours of new and reviewed material at full velocity, you absorb whatever you can, and you come out the other side hoping something stuck.
The fact that we're doing both JavaScript and Python at the same time makes it twice as hard. Every method, every loop, every function has a slightly different shape in each language. The syntax is not identical. And when you're moving fast, you lose track of which rules belong where.
I don't have a great solution for that, other than reps. The immersion thing. The more I see it, the more I use it, the more it stops being a lookup and becomes instinct.
Tomorrow and the rest of the week will tell me if we're going to get any hands-on time or if we're back in lecture mode. Either way, I'm finding the keys.