Best Free Prompt Engineering Courses in 2026 (9 Ranked, ChatGPT and Claude)

Search for prompt engineering courses and you get two kinds of result: paid programs promising a six-figure "prompt engineer" title, and top-ten lists padded out with the same three courses plus filler. Neither helps you pick. Here is the straight version. Prompt engineering is a real skill and a narrow one. The core of it (clear instructions, few-shot examples, giving the model a role, chain-of-thought, and checking the output instead of trusting it) fits into a few hours of good teaching. Everything after that is reps against real tasks. So the useful question is not which course is longest. It is which few hours teach the technique directly, instead of burying it inside a broad tour of generative AI. We ranked 9 free courses from our catalog on exactly that. Every one is genuinely free: no trial that expires before the useful part, no gated final module, no paywall between you and the teaching. They come from Anthropic, DeepLearning.AI, Google, Microsoft, and freeCodeCamp, which is to say from the people who build the models and the people who ship on top of them. Two things to set expectations before the table. This is not a popularity ranking. DeepLearning.AI's ChatGPT Prompt Engineering for Developers carries 142,000 learner ratings against Anthropic's 14,000, and it still sits at number two. The 545,800 ratings behind these 9 courses told us they are all good. They did not tell us which one teaches prompting best, so we sorted on how much of each course is prompting practice instead. And certificates are scarce here. Of the 9, only Google's two hand you one for free, and neither carries much weight on a resume by itself. If a certificate is your main reason for taking a course, skip ahead to the certificate section and set expectations accordingly. If you would rather follow a day-by-day schedule than pick from a ranked list, we keep a 30-day plan built from these same courses at Learn Prompt Engineering in 30 Days. This page answers "which course is best." That one answers "give me a plan."

The top two are the ones most people should actually take, and they answer different questions. Anthropic's tutorial is where you get your hands dirty: nine chapters of notebooks that run against the Claude API, moving from basic prompt structure through role prompting, few-shot examples, chain-of-thought, and how to stop a model inventing facts. Almost every cell is a prompt you edit yourself. DeepLearning.AI's course is where you get the map fast: about an hour of video and notebooks covering the same principles at a higher level, taught by Andrew Ng with OpenAI's Isa Fulford. If you only have an evening, take number two. If you have a Saturday morning, take number one and you will be measurably better at this by lunch. Google's two one-hour courses sit at three and four because they are the only free options here that finish with a certificate, and because the concepts they teach make everything else land better. They will not teach you to write a prompt. They will teach you what the thing on the other side of the prompt is doing, which is why so many people plateau at trial and error without them. Everything from five down is prompting applied to something bigger: pipelines, agents, tool use, and full applications. They are ranked lower for this query, not lower in quality. If your goal is to build rather than to prompt, jump straight to the pick by what you are trying to do table.

Four criteria, in this order. How much of the course is prompting technique. This is the heaviest weight and the reason the order looks unusual. A course that spends three of its four hours on prompt structure, examples, and failure modes ranks above a course that covers prompting well in lesson two and then spends nine lessons on agent orchestration. Both are good courses. Only one of them is a prompt engineering course. Hands-on practice over watching. Prompting is a motor skill more than a knowledge subject. You get good by writing a bad prompt, seeing the model do something stupid, and fixing it. Courses that put you in a notebook editing prompts ranked above courses that show you finished prompts on a slide. This is the single biggest reason Anthropic's tutorial beats a course with ten times the ratings. Free-tier completeness. All 9 pass, but they pass differently. Anthropic, Microsoft, and freeCodeCamp publish everything openly, no account needed. DeepLearning.AI asks for a free sign-in and then gives you the whole course. Google's Cloud Skills Boost needs an account and gives you the certificate at the end. None of them lock the teaching itself, which is why the list is 9 courses and not 20. What you hold at the end. A working notebook you can adapt, a project on your machine, or genuine conceptual grounding. A course you finish with nothing to show and nothing you can do differently on Monday did not make this list. What we deliberately did not rank on: learner review counts. We show them in the table because they are useful context, and 545,800 ratings across 9 courses is a real signal that none of these are duds. But review count measures how many people found a course, not how well it teaches this specific skill. Sorting by it would have put the same three DeepLearning.AI courses at the top of a prompt engineering list, which is exactly the lazy ordering every other list already gives you. One more thing we weighed: whether the course is tied to a single model. DeepLearning.AI teaches against OpenAI's API, Anthropic against Claude, Google against its own models. DeepLearning.AI against Anthropic is the closest pair here, and the two take opposite approaches to free access. The techniques transfer almost completely, so this did not change the ranking, but it is worth knowing which vendor's syntax you will be typing.

The overall ranking answers "which is best." This one answers "what fits in the time I actually have." These courses run from 1 to 11 hours, which is a real spread for a subject people usually want to learn in a weekend.

The honest recommendation for a weekend: Google's Introduction to Large Language Models on Friday night, Anthropic's tutorial across Saturday, DeepLearning.AI's one-hour course on Sunday as a fast second pass on the same ideas from a different vendor. That is six hours and it is more prompting instruction than most paid programs deliver in a month. If you have one hour and no more, take DeepLearning.AI's. If you have one hour and cannot write Python, take Google's Introduction to Large Language Models.

Same 9 courses, sorted by the outcome you want instead of the hours you have.

A note on the last two rows of that table. Both are worth taking, and neither is really a prompt engineering course. LangChain is an application framework, and freeCodeCamp's course is a tour of generative AI in general. They earn their place here because prompting is a real part of each, and because plenty of people searching for prompt engineering actually want to build something. If you know that is you, our free generative AI course guide covers that angle properly.

[Anthropic Prompt Engineering Interactive Tutorial](/courses/anthropic-prompt-engineering-tutorial) is the most direct teaching of this skill available for free. It is a set of Jupyter notebooks published by Anthropic that run against the Claude API. Nine chapters take you from basic prompt structure and clear instruction writing through assigning the model a role, giving it few-shot examples, formatting output so a program can parse it, chain-of-thought prompting, and reducing hallucinations. Nearly every cell is an exercise: you write the prompt, run it, and see what happens. The honest limitation is that it is a repo, not a polished course platform. There is no video, no progress tracking, and you need an API key and enough Python to run a notebook. Take it anyway. The lack of polish is the point: you spend the time writing prompts instead of watching someone else write them. More from this publisher at the Anthropic platform profile. [ChatGPT Prompt Engineering for Developers](/courses/deeplearning-ai-prompt-engineering) is the most-taken course on this list by a wide margin, and deservedly so. About an hour, co-taught by Andrew Ng and Isa Fulford of OpenAI, working in notebooks that call the OpenAI API. It covers writing clear instructions, giving the model time to reason, iterating on a prompt that is not working, summarizing, inferring, transforming, and expanding text. The principles transfer to any model, not just OpenAI's. The honest limitation is depth: an hour is an hour, and you get the ideas rather than the practice. It is the perfect first course and a thin last course. Pair it with the Anthropic tutorial and you have the whole practical core. See more at the DeepLearning.AI profile. [Introduction to Large Language Models](/courses/google-intro-llms) is Google's one-hour explainer on Cloud Skills Boost, and it is the best free answer to "what is this thing I am typing at." It covers what LLMs are, what they are trained on, how prompt design fits into using them, and where they fall down. No coding. It ends with a free certificate. The limitation is that it is a primer: you will finish understanding models better and still not know how to write a good prompt. Take it before the hands-on courses, not instead of them. [Introduction to Generative AI](/courses/google-intro-generative-ai) is the sibling course and the gentler of the two. It explains what generative AI is, how it differs from traditional machine learning, and where it gets used, in about an hour with no prerequisites. It also carries a free certificate. If you are completely new, take this one first and the LLM course second. If you already know what a model is, skip both and start at number one. Both live at the Google for Developers profile. [Building Systems with the ChatGPT API](/courses/deeplearning-ai-building-systems) is the sequel to DeepLearning.AI's prompting course and the point where the subject stops being about single prompts. Two hours on chaining model calls: classifying an incoming request, checking it against moderation rules, reasoning through it in steps, and evaluating whether the output is actually right. The lesson underneath all of it is that production systems almost never rely on one prompt. The limitation is that it assumes you finished the first course; starting here will feel like walking into a conversation halfway through. [AI Agents for Beginners](/courses/microsoft-learn-ai-agents-beginners) is the longest course here at about 11 hours, and the most project-based. Microsoft publishes it openly as a lesson series covering agent frameworks, design patterns, tool use, memory, planning, and putting an agent into production. Prompting shows up throughout, because a badly written system prompt is how most agents fail. The limitation for this query is scope: you are learning agent engineering with prompting as one ingredient, not prompting itself. If you want the broader skill set, this is arguably the highest-value 11 hours on the list. See more at the Microsoft Learn profile. [Build with the Model Context Protocol](/courses/anthropic-mcp-quickstart) teaches the open standard for connecting models to tools and data. About three hours through Anthropic's documentation and quickstarts, ending with a server you have built that a model can actually call. It matters for prompting because a lot of what people try to solve by writing longer prompts is really a context problem: the model does not need better instructions, it needs access to the file. The limitation is that this is documentation rather than a taught course, and it is the least beginner-friendly item here. Do it after you are comfortable calling an API. [LangChain for LLM Application Development](/courses/deeplearning-ai-langchain) covers the framework a lot of production LLM apps are built on, co-taught with LangChain creator Harrison Chase. Three hours on chains, memory, document question answering, agents, and evaluation. It assumes you already know how to prompt and shows you how prompts become components in a larger system. The limitation is framework churn: LangChain moves fast, and some specifics age quicker than the underlying ideas. Take it for the patterns, expect to check the current docs for the syntax. [Learn Generative AI in 23 Hours](/courses/freecodecamp-generative-ai) is freeCodeCamp's wide-angle course on the whole subject, covering models, prompting, and building with them. It is the only item here that needs no account of any kind: open it and start. Our catalog lists it at 5 hours, which is less than the title advertises, so check the current runtime before you plan a weekend around it. The limitation is that prompting is one part of a broad tour rather than the focus, and there is no certificate. It is the best pick if you want to see the shape of the whole field before choosing where to go deep. More at the freeCodeCamp profile.

Course titles say nothing about what you can do when you finish. Here is the honest version. After the Anthropic tutorial: take a prompt that is giving you inconsistent output and fix it on purpose rather than by guessing. You will know when to reach for a role, when to add examples, when to ask for reasoning steps, and how to structure output so code downstream can read it. This is the skill people mean when they say someone is good at this. After ChatGPT Prompt Engineering for Developers: write a working API call with a well-structured prompt and get consistent results back. You will also stop making the beginner mistake of writing one long paragraph and hoping. After Introduction to Large Language Models: explain to a colleague why the model made something up, and why asking it to "be accurate" does not fix that. Understanding the failure mode is what stops you writing superstitious prompts. After Introduction to Generative AI: follow any other course on this list without getting lost in the vocabulary. Plus a certificate. After Building Systems with the ChatGPT API: build a small pipeline that classifies an input, routes it, and checks its own output before returning it. That is the shape of most real LLM features in production. After AI Agents for Beginners: build an agent that plans a task, calls tools, remembers what it did, and recovers when a step fails. Of everything here, this is the one that most directly maps to a job posting. After Build with the Model Context Protocol: connect a model to your own files, database, or internal tools through a standard interface instead of pasting content into the prompt. After LangChain for LLM Application Development: ship a chatbot that remembers the conversation and answers questions about your documents. Two evenings of work once you know the framework. After Learn Generative AI in 23 Hours: hold an informed conversation about the field and know which of the specialist courses above you actually want next. If your goal past all of this is a job title rather than a skill, our AI engineer career guide covers what employers ask for beyond prompting, and the AI engineer learning path sequences it.

Two of the nine. Both are Google's.

Be realistic about what a one-hour completion badge does. It shows you spent an hour on the subject. No hiring manager treats it as evidence you can prompt well, and nobody has been hired on it. What it is genuinely good for: filling a gap on a LinkedIn profile while you change fields, and giving yourself a visible finish line on the first hour of a new subject. If you want something an interviewer will actually engage with, build instead. A small repo with three or four prompts you designed, the failures you hit, and what you changed to fix them is worth more than every badge on this page. Prompting is one of the few skills where you can demonstrate competence in a five-minute conversation, so optimise for having something to talk about. For free courses across the site where the certificate is the point, we keep a filtered list at courses with certificates.

Our catalog has more generative AI courses than the 9 above. Here is what did not make the list, so you know it was a decision rather than an oversight. Retrieval, fine-tuning, and evaluation courses. DeepLearning.AI's RAG and fine-tuning courses are excellent and they are not prompting. They are what you reach for when prompting alone stops working, which is a later problem. Agent framework courses. AI Agents in LangGraph and Multi AI Agent Systems with crewAI are both strong, but they are two layers above the skill this page is about. Microsoft's AI Agents for Beginners is on the list because it teaches the prompting inside agent design explicitly and assumes less coming in. Hugging Face's course series. The LLM course, the agents course, and the MCP course are all free, all good, and all built around open-source models rather than prompting technique. If running your own models is where you are headed, start at the Hugging Face profile instead. fast.ai and the deep learning courses. Practical Deep Learning for Coders, CS50's Introduction to Artificial Intelligence, and Karpathy's Neural Networks: Zero to Hero teach you how models work from the inside. Fascinating, useful, and a completely different subject from writing a good prompt. The general rule we applied: if the course would still be most of itself with the prompting chapters removed, it did not belong on a prompt engineering ranking. For everything in that wider space, the free generative AI course guide is the right page, and the generative AI hub lists the full catalog.

If you take one course, take Anthropic's Prompt Engineering Interactive Tutorial. Four hours, free, and it is the only thing on this list where the majority of your time is spent writing prompts rather than hearing about them. The techniques transfer to every model, not just Claude. If you have one hour, take ChatGPT Prompt Engineering for Developers. It is the highest-value single hour in free AI education right now, and 142,000 learner ratings agree. If you cannot write Python, take Google's Introduction to Large Language Models, then decide whether you want to learn enough Python to do the rest. You will need about three weeks for that, and our Python hub has the free options. The sequence we would actually recommend, and the one the 30-day plan follows: Google's LLM primer for the mental model, Anthropic's tutorial for the reps, DeepLearning.AI's course as a fast second pass from a different vendor, then Building Systems with the ChatGPT API once you want more than a single prompt to work reliably. That is eight hours in total. There is no free course anywhere that will teach you more prompting than those eight hours. After that, stop taking courses. Prompting is a practice skill, and the returns move to writing prompts against work you actually care about. Keep a file of the ones that worked, note why, and re-read it in a month. That habit will do more for you than course ten.