Learning at the pace of AI
11 min read
I don't want to look dumb. But more than that, I don't want to actually be dumb. I already do AI engineering and forward deployed work, and that only works if I actually understand the code I ship. But these days Claude writes most of my first drafts, so it's never been easier to ship fast while bullshitting myself that I know my stuff.
So this is how I try to keep learning anyway.
Admitting what I don't know
The thing I try to do, as early as possible, is admit when I don't know something. Honestly, that's harder than it sounds. If I have a glimpse, an inkling, that I know something about a topic, I tend to generalize it into "yes, I know this topic." And then it turns out I don't, and I end up feeling helpless.
So I have to keep questioning myself. When I catch it, I say it out loud. "I don't know this." Then I break down what I don't know, one by one.
I've been living by what others call the known knowns matrix. It sorts everything into four boxes. Known knowns, known unknowns, unknown knowns, and unknown unknowns. For any topic, this post included, I want to know which box I'm really in.

The known knowns matrix, drawn for this post.
The goal is to notice early, so I can learn earlier and get better earlier.
Studying for CCA-F
The biggest example of this was studying for the Claude Certified Architect Foundations exam. Going in, I already had the fundamentals. What AI is, what LLMs are, what skills, agents, and MCPs are.
Then I started taking mock exams and reading the exam guide without reviewing first, and it humbled me fast. The exam also covers how to deal with customer and client behavior. I had surface knowledge of the best way to approach things, but it doesn't always turn out that way. Picking the right answer quickly takes the instincts of an experienced AI engineer, and those come from experience I was still building.
Add to that the more careful ways of applying and combining skills, MCPs, agents, subagents, and workflows, and suddenly I had so much more to learn before I could call myself ready. So I told myself I can't take this exam with what I have coming in. I have to either start from scratch or reevaluate what I know and pick myself up from there.
How I studied with Claude
I studied one domain at a time. There are five domains in the exam, and one of them is context management and reliability.
For a session on that domain, I'd feed Claude the exam guide and have it ask me questions from it, or questions like them. I wanted it to grade my reasoning, not just my final answers. That way it has enough context to see what I'm confused about or what I'm misreading.
That's also why I talk a lot when I work with Claude, kind of like I'm doing in this post. I give it everything I'm thinking, so it can go "okay, this is what Brian was thinking, let's correct that way of thinking" and the correction actually sticks the next time.
After that pre-test came a lesson. I usually used Matt Pocock's teach skill when I wanted to go deeper on a domain or a topic. Once I felt ready, Claude gave me a post-test, with questions that were the same kind as the pre-test, sometimes even the same ones. Then we compared. Did I actually improve or not?

My study loop for the exam, drawn for this post.
It took a lot longer than I expected. But it worked, and the stuff stayed in my head. I got 970 out of 1,000 on the real exam.
Turns out this isn't a new idea. It's pretty much Kolb's experiential learning cycle. You try something, look back at what happened, figure out a better way to think about it, and try again. That's basically my pre-test, lesson, post-test loop.

Kolb's experiential learning cycle, by Derek Jansen, Grad Coach, on Wikimedia Commons, licensed under CC BY 4.0.
Approving changes
If you get a chance to look at my sessions with Claude, you'd see me approve a lot of things with one letter, or a quick "yes, do that." That might look like I'm not paying attention.
Most of those come from grilling sessions. I also use Matt Pocock's grilling skills, where my agent grills me on design and implementation decisions one question at a time, gives me some choices, and suggests one. To answer those, I need enough domain knowledge already. And usually the suggestion is good. When it's already what I'd pick, explaining myself again is just a waste of tokens and context.
When something is worth slowing down for, I slow down. Sometimes Claude suggests what would normally be correct, but my situation rules it out. Then I say "let's not do that," give it more context, and we go back and forth.
Other times I'm the one missing context. Then I stop and say, pause, teach me first how that works. It teaches me with a lesson, or a prototype, or a high level diagram, or by explaining it like I'm five. Once I can answer the question, I answer it and we keep going.
I'd rather look dumb for a minute than actually be dumb. So I ask Claude to teach me the way I need to be taught. That way, when I do approve something, I know what I'm approving.
This is slower at the start, because I'm making all the decisions myself. But once they're made, the implementation can mostly run on its own, because we already agreed on how it should go.
Getting plain explanations
Ever since Opus 5, Claude has had a big tendency to over explain and sound a lot smarter than it needs to. For someone who's trying to learn, that's very annoying. For someone like me who's fluent in English but whose first language isn't English, it takes a while to get used to that very verbose, very intelligent way of talking. I have to take a second just to understand what it said.
I'm not the only one who noticed. Other developers have written about Opus 5's big words and long replies. Anthropic says it too. Its Opus 5 prompting guide says Opus 5 gives longer replies than earlier models by default and that you should ask it to be concise.
So my global AGENTS.md is basically a record of this annoyance. For months I kept making small changes to it. Then I gave up on that and rewrote the whole thing around a few rules.
- Put the answer first.
- Explain things in plain words.
- Use one name for one thing, so I don't mix them up.
- Give one concrete example, but only when the idea isn't clear without it.
- Say the literal thing. No fancy metaphors that make me work harder to get the point.
Even after all that, Claude still over explains, so I'm already planning the next rewrite. It's a real pain point, because every extra layer of wording slows down how fast I learn.
It also made me think about how I explain things to people. When I teach someone something, I try to keep it conversational, the way people actually talk. I think that's the whole point of teaching. You don't teach someone from the level where you are. You teach them from the level where they're trying to learn.
Checking the agent's work
Understanding the code is also how I catch the agent being wrong.
I once picked up an internal tool that began as a quick prototype built on a third party API. My job was to turn it into something people could rely on every day. So once I understood what it was for, I read the API's documentation, the product's features, and the codebase from end to end.
The documentation is as close as you can get to a source of truth, because the service provider wrote it. While reading it, I noticed the code was trying to read a field from the API that doesn't exist. That was odd, because a lot of other tools relied on that field.
That's normal for a prototype. It's built to prove an idea fast, not to match every field in the docs. If I hadn't caught it then, I would have kept building the more complicated tools on top of it. Eventually something would keep failing and I wouldn't know why, and I would have wasted a lot of time trying to debug it. I was really relieved I caught it when I did.
Learning with AI vs. letting AI do the work
So where does learning with AI end and letting AI do the work start? Honestly, it's not a fine line. It's about delegation, and that goes for AI help in general. You don't want AI just giving you slop, and you don't want it doing the parts you don't understand yet.
At work, how I do it is pretty simple. I learn the thing first, then I make the decisions, then I have AI do the implementation, and then I verify it. Just because AI wrote the code doesn't mean I don't know what's going on. It means I'm letting AI do the work I already planned out.
School is different. My school has its own policy on generative AI, and I follow it, so there AI is mostly my teacher. I use that approach because school teaching is practically standardized, one teacher for all. Having an AI that can teach you the way you prefer to be taught is such an advantage, and it'd be a shame not to use it. Just don't abuse it to do your work for you. Know the material, learn the material, and have your AI test you on it.

The Feynman technique. Flowchart by WiredAlexandria on Wikimedia Commons, licensed under CC BY-SA 4.0.
If you're just starting
Say a first year computer engineering student walks up to me and says they just installed Claude Code and want to learn. The first thing I'd ask is what they actually want to learn. Do you want to learn how to build a product, or how to do proper engineering? Those two get approached in really different ways, right?
If you want to build products, the best way to learn is to build. Even if you vibe code at first, you break stuff and you learn from breaking it. The loop is brainstorm, build, get feedback, and that feedback is arguably the most important part. Your agents, your users, and whoever reviews your work will all ask you questions like these.
- Have you considered a different approach?
- How are you handling security?
- Where does your data live, and why there?
You learn what each of those means one by one.
If you want to learn how engineering actually gets done, Claude Code can be a good teacher first. There are a lot of skills and workflows that turn it into one. You just have to say what you want to learn and how you want to be taught.
The middle ground is what I do now. It's slow but steady, and it's learning while shipping. Take your time to learn something, grill the heck out of yourself with your AI, and agree on what you know before you build. Then do a retro. What did we do wrong, what did we learn, what did we miss, what could we improve? Then do it again.
Either way, you have to get familiar with the fundamentals. AI is a multiplier. It amplifies what you already know, and zero amplified by even 100x is still zero. So know your stuff first. Then let AI push you forward.