AI-Application Developer Program

This program never launched, but it was going to be an absolute banger. It ended up a casualty of the rapid rate of AI development in 2025.

One of the largest tech companies in the world was preparing a major release of an open-weight model, and it needed a program to teach working engineers how to build real applications on it. People with a few years of Python and an API key, but no map of what they needed to learn to build with these fancy new AI tools. This was another project where I was brought in early, helping go over the spec and shape the initial design of the curriculum.

The plan was straightforward. LLMs like GPT had taken the market, the upstart Anthropic and their Claude models were gaining steam, Gemini was in the fray, and people everywhere were realizing these chat interfaces were amazingly powerful and starting to ask what they could build with them. What tools would someone need to know? We wouldn't go deep into how a neural network works. We'd stay higher level. How does one make an agent, something that keeps going around a problem instead of stopping after a single response? What is this new RAG thing, should it be included, is it going to be a significant advancement? Writing this almost two years later, every one of those questions is still largely unanswered. We were working at the leading, and often bleeding, edge of this kind of content.

I had earned my seat on the team through several years of curriculum work, helping Aptly on the Meta and Google Coursera programs, building my own Udacity API course from top to bottom, then scripting and on-camera work for Microsoft's developer certificates. This project took things further. I came in earlier in the process than ever, helping steer the technologies the program would teach.

As with most great tech content, the tools were so new that almost nobody knew how to work them, and the people who did were busy working at the major labs. Our job was to go learn them, then work with the client's technical staff to distill each technology to its core in a way a learner could understand. Like so many developers, I had been working heavily with AI but had never built my own agentic workflows, so we had to dig into what tools people were actually using. Not only were the tool categories themselves brand new, each one had multiple contenders bubbling up, and part of the job was judging which was the right one to hand our learners.

The content covered a huge depth. The vision of taking a learner from just knowing how to write Python all the way up to building and deploying their own AI applications was ambitious. We would start with foundational topics, inspecting raw prompt formats without high-level APIs and making chat requests over plain HTTP, so a learner sees exactly what happens during a turn and that there is no magic. Prompt engineering, the absolute hotness of the moment, chaining prompts, refining them, scoring them against each other instead of eyeballing. Turning model output into real software instructions and validating them with Pydantic. Using the guardrails built into the model itself. Managing conversation state with truncation and memory. Building parameter grids to run side-by-side comparisons and watch how real token costs traded against performance. Then building actual apps with Gradio and Streamlit, feeding the model additional context through RAG and agentic search, and finally deploying with Docker and Hugging Face Spaces, external documents hosted for retrieval into context.

The original vision had every learner standing up the model locally and developing on their own machine, a dream that didn't account for what the model's touted headline, that it could run on a single H100, meant for a home computer enthusiast. Quantize it down to near-potato status and you could just barely get it running on a Mac M1, in a lobotomized state. After some convincing we got the client team to see that these models were simply too large for anyone outside an enterprise environment with access to very expensive hardware, which is why we ended up using Together as the hosting platform for the model. The program was massive, and timed just right. There was just one big problem.

This turned out to be one of the fastest periods of development and improvement in the history of AI applications. We were just coming into tool calling, nobody had cracked proper agentic loops, and then Claude Code happened and absolutely shattered what the world was doing with these tools. People stopped asking how to hand-roll their own loops and started asking how to wield the new agentic tools. DeepSeek and the big Chinese models arrived and pulled attention toward the next generation, and a new model has landed roughly every week since. Shifts that large are enough to spook any course sponsor. The client shelved the launch, waiting for the dust to settle. The dust has not settled. It may never settle. The world is moving at an absolutely lightning-fast clip.

I'd still love to see a course like this come to fruition, because the material helps people understand what's actually happening under the hood of these tools. A lot of pieces have to make sense together for a good agent setup to work, and even in a world where LLMs and agents write and run more and more of our code, a basic understanding of what's possible, how the network traffic flows, and what the raw inputs and outputs look like helps you build better applications faster. If this project taught me anything, it's that designing around the speed of AI is going to be hard for years to come. The world will keep shifting, which means always sorting what will still be relevant a generation or ten out from what should be moved past quickly. Otherwise you'll build the perfect ambitious project just in time to hit the next revolution halfway through.