The engineers getting the most out of coding agents are not renting a better model than you. They know a list of things. This class is most of that list.

I Teach 4,000+ Engineers. Ex-YC Technical Founder. Cambridge Physics Grad.
People who aren't keeping up even over the last 30 days already have a deprecated worldview on this topic
Andrej KarpathyCo-founder of OpenAIEveryone reading this rents the same model.
Same weights. Same context window. The same API, at the same price, with the same rate limits. Nobody in your industry has a better one, and if a better one ships next month, everybody gets it on the same morning.
And yet the results are not close.
There are engineers getting two times out of these tools. There are engineers getting a hundred times out of them. Same ability. Same codebase. Same subscription. Same week.
That is not a rounding error. That is a different career.
If you are in the first group, I would not get comfortable there. Two times is what the tool gives you for switching it on. Everybody got that, which is exactly why it is worth nothing. It is the floor now, not an achievement, and the distance between the floor and the ceiling is getting wider rather than narrower.
That gap should bother you, because it rules out the explanation everybody reaches for first. It is not the model. You have the same one.
It is also not talent, and I want to be blunt about that, because the talent story is the comfortable one and it happens to be wrong. I have watched genuinely excellent engineers get very ordinary results out of these tools. I have watched competent, unremarkable ones get extraordinary ones.
I have spent 4,500+ hours on this, on code that people pay for, and here is what I think is actually going on.
The difference is a list of things you either know or do not know.
Not a talent. Not a mindset. Not a secret setting. A list. It is finite, most of it is unglamorous, and almost none of it is difficult once somebody tells you what it is. The people ahead of you are not cleverer than you. They found the items earlier, usually by wasting an enormous amount of time.
Nobody hands you the list. That is the actual problem. You get told to use the tool. Then you are alone with it, and you discover items at the rate accidents produce them, which is roughly one a fortnight if you are paying attention.
I have tried to write this list out properly several times. Every time, the items fall into the same four piles. If you are behind, you are behind in one of these, and usually you can name which one before you finish reading them.
Not how large the window is. What is actually in it when the agent starts.
Everything the agent needs either reached it before it started, or it is guessing. A confident guess is indistinguishable from knowledge, right up until it lands in a diff.
Read a diff and ask what you are actually doing. You are checking it against rules you keep in your head.
If the rules only exist in your head, you are the last thing standing between a bad change and the main branch. That is why you can never leave.
One agent that stops to ask you things is a faster version of you. Three agents that stop to ask you things is a worse job than the one you had.
The difference is not the tooling. It is how much of the work has to come back through a person.
A great deal of what gets called an agent failure is a task no human could have finished either.
Scoping, decomposing and specifying are the oldest skills in this job. Agents made them pay immediately instead of eventually.
Every item on the list lives in one of those four piles. Every one of them is learnable, and I mean that in the ordinary sense: somebody can tell you, you can try it on Tuesday, and you will know by Friday whether it worked.
You do not need me for the first step, and I would rather you did it yourself, because the argument only lands if it is your own data.
Take one afternoon of real work. Every time the agent stops and waits for you, write down what it wanted. Do not fix anything, just record it. It will be the same handful, over and over:
Now sort your list into the four piles. Nearly everybody finds their afternoon lands heavily in one of them, and that pile is where their multiple is being lost.
Then do the arithmetic, because the arithmetic is the part that changes minds. Say each interruption costs you five minutes, and they arrive every ten.
Annoying and entirely survivable. You call it collaboration, and honestly it feels quite good. This is where nearly everyone is, and it is exactly why nearly everyone reports the same modest multiple.
The interruptions now arrive twice as often, out of order, on two unrelated pieces of work. Each one costs you the reload of whatever you were holding in your head, which is the expensive part and never shows up in the five minutes.
You are not engineering any more. You are a queue, working through an inbox you generated yourself, and the agents are idle more than they are running.
This is why people say agents do not scale. Agents scale beautifully. The person sitting in the middle of every iteration does not.
You cannot review your way out of this.
And please do not try to solve it by being faster or better organised. Reading diffs more quickly does not raise your ceiling. It moves you closer to it.
Here is the reason I am confident the list is learnable rather than innate. Our field has met this exact problem repeatedly, and it has always had the same answer.
Notice what we did not do, not once. We never decided to do the check faster.
Every time, we moved the check. We took a judgement that lived in a person, put it somewhere it could run without that person, and kept the human for the cases that genuinely needed one. Nobody calls that a talent. It is a set of techniques, and every one of them was taught.
Agents have brought that same moment forward and made it personal rather than organisational. The check that is now the constraint is you, reading a diff. The answer is the answer it has always been.
Your standards live in your head, which is exactly why you are in the loop.
So here is a piece of the list, written out. Each row is a decision you currently make in person, and where it goes instead.
becomes a verifier that fails the build, so the answer arrives before you do.
becomes an architecture note the agent reads before it writes, rather than a correction you make afterwards.
becomes context that outlives the session, instead of a paragraph you retype every morning.
becomes a handoff you take deliberately, before the window fills and the output quietly degrades.
becomes decomposition done at planning time, rather than discovered at hour three.
becomes a permission decided once, rather than a prompt you answer on every action.
becomes a check that looks before it approves.
becomes a specification sharp enough that the question never gets asked.
Read that list again and notice what it is not. It is not a list of features, and it is not a list of prompts. It is a list of places to put a decision. That is what the whole thing is made of.
The Agentic Coding School doesn't just show you what buttons to press, it builds genuine understanding from the ground up. By the time you're two-thirds through, you're not just using the tool, you're thinking in it.
That is the plainest way I can describe what you are buying.
Not a tour of the tools, and not a prompt collection. It is the list, sorted into the four piles, in the order I would teach it to somebody sitting next to me, with the reason each item works so you can tell when it does not apply.
I am not going to claim it is all of the list. Some of what separates two engineers is specific to one codebase, one team and one set of constraints, and nobody can teach you those from a video. You will still find them yourself. You will find them considerably faster once the general items are in place, because most of what slows that down is not having a framework to hang a discovery on.
What I will claim is that the vast majority of the learnable part is in here.
That is what Agentic Coding for Engineers is: a self-paced video class, lessons across 8 modules, in three parts. Part one is the tools properly, Claude Code and Codex, because you cannot build a system on a tool you only half understand. Part two is the techniques you reach for in every session. Part three is the system around the agent, which is where the first two start paying.
It assumes you write software for a living, and that you have used one of these tools enough to be frustrated by it. It is not a beginner's tour.
I have taught this on YouTube for a while, and the material there is generally considered the most advanced agentic coding content available for free. This is the version with the gaps filled in and the order fixed. There is a limit to what a standalone video can do: it cannot assume what you already know, so it has to start again every time. A class can build, and building is the whole point of this one.
Get through it and your position changes. You stop being the thing in the middle and become the thing at the edge: choosing what gets built, setting the standard it is held to, and reading outcomes instead of diffs.
lessons across 8 modules, in three parts. Each part assumes the one before it, and the order is the order I would teach it in person. Every lesson title below comes live from the catalogue, so what you see here is what is in the class today.
Install them, drive them, and read what they are doing on your behalf. Claude Code end to end, then the same work in OpenAI's Codex, and the places where the two genuinely diverge. It is the longest part for a reason. Almost every later item is a decision about how to configure, constrain or extend the tool, and none of those decisions make sense while the tool is still a black box.
The tool end to end: install it, drive it, and read what it is doing on your behalf.
The same work in OpenAI's Codex, and where the two tools diverge.
The moves you reach for in every session, each with the reason it works. Fundamentals first: what to do when a session stalls, when to start again, when to compact and when to hand off. Then the advanced patterns, which only begin paying once the fundamentals hold. If you have ever watched a session go in circles and not known which lever to pull, this is that part.
The moves you reach for in every session, and why each one works.
What to do when a session stalls, and the patterns that only pay off once the fundamentals hold.
Context engineering, so the agent knows what it needs and keeps knowing it. Prompt engineering, so the answer does not need a second attempt. The daily workflows I run on production code, from the first message to the merge. And what changes when a business depends on what the agent ships, which is a different problem from a side project. This is the part that takes you out of the loop.
Give the agent what it needs to know, and keep it across sessions.
How to ask, so the answer does not need a second attempt.
The routines I run on production code, from the first prompt to the merge.
What changes when a business depends on what the agent ships.
All four piles, taught properly: what to give the agent and what to leave out, the checks that catch a bad change before you do, the loops you can start and walk away from, and how to shape work so an agent can actually finish it. Context first, because a check cannot help an agent that was never told what good looks like here. Then the checks. Then the loops the first two pay for.
Every one of them, and every one available the moment you buy. Nothing is drip fed and nothing unlocks later. No filler, and no lesson that exists to pad a curriculum page. Yours permanently.
The same work in both tools, including where the two genuinely diverge. The principles are the durable part, and you should be able to watch them survive a change of tool.
Connect the class to your own agent. It reads what you are working on and points you at the lessons that apply, which is a better way to find the right video than scrolling a list.
English, Spanish, Arabic, French, German, Portuguese, Japanese, Russian, Traditional Chinese and Thai. English is human, the rest are AI-generated, and every lesson is covered.
The members-only server, with the other students and with me. A good number of them are further along than you on exactly the thing you are stuck on.
The list grows, and you get the new items. Everything here is yours to keep and to come back to, as a reference, as a refresher, or because the tool changed again and you want to see what that means.
Engineers have taken this class, including CTOs at multi-billion-dollar startups and at Fortune 500 companies. These are their words, not mine.
The Agentic Coding School doesn't just show you what buttons to press, it builds genuine understanding from the ground up. By the time you're two-thirds through, you're not just using the tool, you're thinking in it.
This is not the typical get-rich-quick hustle program you see on social media. Ray works deep in the inner workings of the models and knows how to be productive with them. I am convinced he uses Claude Code as well as or better than most Anthropic engineers.
I went from treating Claude Code like a chatbot to running it like a full development platform. The lessons on hooks, subagents, and CLAUDE.md files alone were worth it.
I already had experience with Claude Code, and this still took me further. Seeing your everyday usage throughout the course is genuinely valuable, not just some vibe coding app. I learned a lot from the multi-agent plan execution and the spec-dev command.
One payment of $397 gets you everything, forever. Every class, every update I ever ship, and every new class I release, included at no extra cost. No subscription, no renewals.
Yes, and you're the person it moves fastest. You already have the judgement, which is the part that takes years. What you're missing is a process you trust enough to step back from, and that's most of what this class is.
No, but it helps. Everything is taught against real code with real constraints, and it applies just as well to a side project. If you do have work in front of you, use it. The material is much sharper when it costs you something.
Longer in practice than in video, if you do it properly. The curriculum section on the class page prints the runtime of every module live from the catalogue, so you can add it up before you buy rather than take a number from me. Most people don't watch it end to end anyway. They work through Part 1, apply it for a week, and come back for the parts they now have a reason to care about. The MCP server exists to make that way of using it easy.
A way of working, taught through those two tools because they're the best available right now and because you can't learn this in the abstract. When they're replaced, the specifics change and the argument doesn't.
You're in the right place. Most people hit this wall: you know these tools can do more, but you don't know what you don't know. The class starts from the fundamentals and builds systematically so you understand not just the features, but how to combine them into workflows that actually save you hours, across both Claude Code and Codex.
All video. Every lesson is me on screen, walking through real workflows and features in Claude Code and Codex, not a wall of text or a Notion doc dressed up as a course. You see exactly what I type, what the agent does, and how I respond when things go sideways. Watching someone actually use these tools teaches you ten times faster than reading about them.
Especially you. Even daily users tend to plateau at 20-30% of what these agents can do, because the next 70% isn't more prompting, it's engineering. Hooks, subagents, skills, MCP servers, /goal mode, loop engineering, and multi-agent workflows that most people don't even know exist. That's the gap between using the tool and building systems on top of it.
Yes, and you should use the docs as a reference. But there's a difference between a reference manual and a guide. The docs tell you a piano has 88 keys. This class teaches you how to play. You could figure it out alone, but it would take 40x longer. Think of it as trading a bit of money to save yourself a lot of time.
Your account will be created automatically after purchase and you'll be sent an email with your login details to the same email you used at checkout.
Plan on the $100/month tier (Claude Max, or the $100 Codex plan), it's the sweet spot once you're running agents continuously. The $20 plans work to follow along but run out fast, and $200 suits heavy autonomous runs. Most people use both. If you use one, there's still a lot you can learn from all the classes.
Yes. Most people purchase it through their companies or using their company's learning stipends and professional development budgets. $397 is typically an easy approval. You'll automatically receive a proper invoice after purchase. If you have custom invoicing requirements, email me at r@rayamjad.com.
No, that's exactly the problem this solves. Unlike most classes, this one is kept current as the tools change, because I use both of them every day myself. Your purchase covers every update to this class. When new features ship, you get updated videos, not stale content collecting dust.
That would be great. It'd mean the tools are getting even better. The skills in this class transfer across agentic coding tools, so they don't go to waste when the landscape shifts. If I ship a class on a new tool, students with active access get it included, free.
Most classes on this subject are taught by people who do not ship. They read the documentation, theorise about it, and package the result. I ship constantly, and every lesson here came out of that rather than out of the docs.
Company work: AgentStack and Impello. My own products: HyperWhisper and TensorAI. Between them they have hundreds of thousands of end users. All four are built with the tools this class teaches, in the way this class teaches them.
Two things shape how I teach. First principles, because that's how I learnt during my Physics undergrad at Cambridge. And a problem-and-solution structure: I describe the problem first, then show the solution. That ordering creates a slot in your brain for the solution to land in, so you actually remember it a week later.
Yes. I used to believe some coding background helped, but with today's models that's no longer the case. The real skill is being able to clearly articulate your thoughts and ideas and collaborate with the model. That's something anyone can develop over time, and the class covers many techniques to help you do exactly that.
30-day money-back guarantee on your first individual purchase, provided you've watched less than 60% of the video content (about 204 videos). Email me at r@rayamjad.com within 30 days. This applies to your initial individual purchase only, not team plans or subsequent renewals.
Yes! Team discounts: 30% off (3-9 seats), 40% off (10-19 seats), 50% off (20-49 seats), 70% off (50+ seats). Team purchases are not covered by the money-back guarantee. For teams greater than 100+, email r@rayamjad.com for enterprise inquiries.
Yes. English audio, with subtitles in 10 languages: English, Spanish, Arabic, French, German, Portuguese, Japanese, Russian, Traditional Chinese and Thai. The non-English ones are AI-generated, so expect the occasional rough edge. Plenty of non-native speakers have said they're still very useful.
Most students don't watch it in order. They jump to whatever they need that week. The class includes an MCP server that connects to Claude Code or Codex. Describe what you're working on and your agent sends you straight to the relevant lessons in the optimal order for you. No linear path required.
Ask Claude or Codex. The class includes an MCP server that gives both full knowledge of every video and your progress. Describe what you're building, what you want to learn, or even just your role, and it sends you straight to the right lessons. A product manager gets different recommendations than a senior engineer. No browsing, no guessing.
It does the opposite, and this is the objection I'd most like to answer properly. A better model is a better reader, and a better reader extracts more from the same brief. When every engineer is renting the same excellent model, the model stops being the differentiator. You are. What you hand it, and when, is the only thing left that is not identical across your entire industry, and that is what this class teaches: the differentiators that get better output out of the model you already pay for. Every release the labs ship is a free upgrade to a system you already own. It makes the list more valuable, not less.
Reading code is good engineering. Being the only thing that reads it is a single point of failure, which you already know from every other part of the job. The aim isn't to stop looking at code. It's to make sure that when you look, it's because you chose to, not because nothing else could.
However many you can keep supplied with good work, which for most people starts at one. The number isn't the point. The point is that the number is currently capped by your attention rather than by anything about the tools. Plenty of students apply all of this to a single agent and simply get their afternoons back.
Yes, and arguably more. A required review is exactly the constraint that makes the rest worth building: the more expensive the human check is, the more you want everything a machine can catch caught before it reaches one. None of this asks you to remove a review gate. It asks you to stop using your review as the first line of defence.
Yes, please do. Email me at r@rayamjad.com. It comes to me rather than to a support desk, and I read and answer every one. Ask whatever you need before you buy: whether it suits your team, what your invoice has to say, or whether the class covers the problem you actually have.
We offer regional pricing in some countries. Checking whether yours is one of them.