You are on the pro shelf now
You started this course unable to write code. You have built a tool that reads a folder, calls a model, validates what comes back, handles its failures, writes a spreadsheet, retrieves from a collection by meaning, and serves a web page. That is roughly 120 lines of Python.
It is worth being precise about what that means, in both directions.
What you can actually do now
You can build the five-part shape, which is the architecture of essentially every AI application: input, prompt assembly, model call, parse and validate, output. Products differ in scale, polish, and integration, not in shape.
You can read an API's documentation and use it. The specific library does not matter — you now know what a client, a model parameter, a token limit, and a response object are, and every provider has the same four.
You can debug. Read the bottom of the traceback, print the thing, cut the problem in half, change one thing. That transfers to all programming, not just this.
You can tell a real claim from a vague one. When someone says their product is "AI-powered", you know what is underneath: a prompt, a loop, some parsing, probably retrieval. That is not cynicism — it is the ability to ask a useful second question.
What production adds
Everything you skipped, and it is a lot: a server that stays up, secrets management, authentication, rate limiting, monitoring and alerting, evaluation harnesses that tell you whether a prompt change helped, caching, cost controls at scale, versioning so you can roll back a change, and tests.
None of it is mysterious. All of it is work, and it is most of the work — which is the honest reason a demo takes an afternoon and a product takes months.
The specific next courses
If retrieval was the interesting part — and for most people it is — Building RAG Systems is lesson 11 done properly. Chunking strategies, vector databases, reranking, and evaluation, which is the part that separates a working system from a demo. You will recognise every problem it solves because you have just built the version that has them.
If the prompt was where you spent your time, Prompt Engineering and Context Design is the deep treatment — system prompts, structured outputs, chain-of-thought, and the context patterns that make models reliable rather than merely impressive.
If you want to go wide on one provider's full surface, Claude for Developers runs from the first API call through tool use, MCP, multi-agent systems, and the AI-assisted development lifecycle. It starts where lesson 3 started, so the beginning will feel like revision, and then keeps going for twenty-four lessons.
If you kept wanting your tool to decide things rather than follow steps, that instinct is the agent question, and AI Agents in Production is where it leads — the agent loop, tool calling, memory, and the guardrails that make any of it safe to ship.
If you want the ground underneath all of it, Tokenization, Attention Mechanisms, and The Transformer Architecture are the machine itself, from first principles. The first two are free.
What to build next
Not a bigger version of this. A different shape, so you meet different problems.
Something that classifies rather than extracts — routing incoming messages into categories. You will meet the problem of a model that will not stick to your category list, which teaches you more about constraining output than any amount of extraction does.
Something with a conversation — where the model needs the previous turns. You will meet the context window, and the fact that a conversation is a list you manage rather than a thing the API remembers.
Something that uses a tool — where the model can ask your code to look something up, and you feed the answer back. That is the doorway to agents, and it is about thirty lines.
Each is a weekend. Each teaches one thing this course could not.
The last thing
The most common way a first project dies is not difficulty. It is that it was never quite finished, and finishing is a separate skill from building.
So: take the tool you have, use it for something real this week — your own meeting notes, your own folder — and notice what annoys you about it. That annoyance is the specification for version two, and it is worth more than any tutorial, because it came from use rather than from a lesson.
Do this today: run your finished pipeline on ten real files of your own. Then open the CSV. Whatever you find wrong with it is the beginning of the next thing you build.