Build with AI: APIs, agents and small apps

Call model APIs, get structured output, search your own documents, build tool-using agents and ship a small tested app.

Chat assistants are useful, but at some point you want AI inside your own tools: an app that reads your documents, sorts your data or takes actions for you. Getting there means learning what the chat window hid from you. Models forget everything between calls, output needs a schema before code can use it, and agents need limits or they loop. Prompt injection can turn your own app against you. This course teaches each of these with small builds, using an AI coding assistant to write most of the code while you learn to read it, test it and ship it.

What you'll be able to do

• Call a model API from a server with the key stored safely and read token usage to estimate cost
• Get schema-validated JSON output and handle bad or truncated responses
• Build retrieval over your own documents with embeddings, vector search and cited answers
• Define tools for function calling and validate every argument before acting
• Build an agent with step, cost and time limits and human approval for actions
• Ship a small app built with an AI coding assistant, in version control and deployed
• Write and run an eval set that compares prompt or model versions
• Test your app against prompt injection and misuse and fix what you find

Syllabus

Module 1: Make your first call to a model API

You will learn what you send to a model API and what comes back, how to keep your key safe, and how to read token usage so you can work out the cost before you build.

• 1.1 What actually happens when you call a model API
• 1.2 Keep your API key on the server, never in the browser
• 1.3 Tokens, pricing and limits you have to plan around
• 1.4 Send your first request and read the response

Module 2: Get output your code can use

Set fixed rules with a system prompt, ask for JSON that matches a schema, and deal with the bad, empty or malformed replies that real traffic brings.

• 2.1 System prompts set the rules for every request
• 2.2 Ask for JSON and enforce it with a schema
• 2.3 Handle a bad response without crashing
• 2.4 Build an extractor that turns emails into JSON

Module 3: Answer questions from your own documents

You will build search over your own files. You turn text into embeddings, split and store your documents, find the parts that match a question, and have the model answer only from those parts.

• 3.1 Why you retrieve instead of pasting everything in
• 3.2 Embeddings turn text into numbers that capture meaning
• 3.3 Split, store and search your documents
• 3.4 Make answers cite their sources and admit gaps
• 3.5 Build a question answering tool over your notes

Module 4: Let the model call your functions

Give a model tools it can ask to use, and describe them well enough that it uses them correctly. Your code checks every tool call before acting on it, the same way it would check any untrusted input.

• 4.1 How tool calling works: the model asks, your code runs
• 4.2 Write tool descriptions the model uses correctly
• 4.3 Check every argument before you act on it
• 4.4 Give an assistant a calculator and a lookup tool

Module 5: Build an agent that knows when to stop

You will turn tool calling into an agent loop and set hard limits on steps, time and spend. You will also learn the ways agents fail and how to keep a person in charge of actions that matter.

• 5.1 An agent is a loop: decide, call a tool, look, repeat
• 5.2 Set limits on steps, time and spend
• 5.3 How agents fail: loops, drift and false success
• 5.4 Keep a person in the loop for actions that matter
• 5.5 Build a research agent with a hard step limit

Module 6: Build a small app with an AI coding assistant

You'll scope an app small enough to finish and write a spec before asking for any code. Then you'll build it in small, checked steps with version control, and debug without going round in circles.

• 6.1 Pick a project small enough to finish
• 6.2 Write a spec before you ask for code
• 6.3 Work in small steps and read every change
• 6.4 Debug with the assistant without going in circles
• 6.5 Ship a small working app

Module 7: Test the output before you trust it

Stop relying on spot checks. Build a test set from real cases, score outputs with exact checks, rules and model graders, and compare versions before you ship a change.

• 7.1 Why trying a few prompts by hand is not testing
• 7.2 Build a test set from real cases
• 7.3 Score automatically: exact checks, rules and model graders
• 7.4 Run an eval before and after a prompt change

Module 8: Keep it cheap, fast and safe

Make your app cheaper and faster without losing quality, defend it against prompt injection, and handle keys, personal data and logs properly before real users arrive.

• 8.1 Cut cost and latency without hurting quality
• 8.2 Prompt injection: when your input gives orders
• 8.3 Secrets, personal data and logs
• 8.4 Attack your own app before someone else does

Frequently asked questions

How long does the course take?

About twelve hours of lessons and builds across eight modules, plus the final project. Most people take six to eight weeks at two to three hours a week.

Do I need to know how to code?

You need to be willing to read code and run it. An AI coding assistant writes most of it, and each lesson explains what the code should do in plain words first. Some prior experience with any programming language makes the course faster.

Which model provider should I use?

Any major provider works, such as OpenAI, Anthropic or Google. The ideas are the same across them. Models, prices and limits change often, so the course shows you where to look them up rather than quoting them.

What will it cost to run the exercises?

You pay the model provider for what you use. The builds are small, and you set a monthly spending limit in lesson 1.1 before making any calls. Check current pricing on the provider's page.

How is this different from Automate your work with AI and no-code tools?

That course builds automations in tools such as Zapier, Make and n8n without code. This one works directly with model APIs and code, which gives you more control and more responsibility for security and testing.

Explore more

• All Academy courses