Practical AI: From Everyday Use to AI Application Development

Topics covered

• Class 1 (free trial class): Use AI today, see what you'll build
• Class objective: Get real value from AI, understand its limits, and see the application you will build. Instructor-led content: Introductions and course goals. Models, prompts, context and answers in plain language. Text, image, audio and multimodal capabilities. Hallucinations, out-of-date knowledge and checking answers. What must never be pasted into public AI tools. A demo of a finished course application. Hands-on work: Use an AI assistant for a task from your own life or job. Compare two assistants on the same question and find an unsupported claim. Student deliverable: AI capabilities and limits checklist. Between-class practice: Keep a log of useful and unreliable answers.
• Class 2: Prompting for useful, structured results
• Class objective: Turn vague requests into reusable prompts. Instructor-led content: Goal, context, constraints, examples and output format. Iterating and revising. Asking for tables, checklists and structured output. When not to over-prompt. Hands-on work: Rewrite weak prompts and build one reusable prompt template. Student deliverable: Prompt template library. Between-class practice: Test one prompt across several models.

Topics covered

• Class 3: AI for research, writing and analysis
• Class objective: Use AI as an assistant while a human still verifies. Instructor-led content: Breaking research into questions and gathering sources. Drafting, rewriting, summarizing and translating. Explaining data and spreadsheets. Verification and citation habits. Hands-on work: Create a sourced brief and verify every important claim. Student deliverable: Verified AI-assisted brief. Between-class practice: Create a verification checklist.
• Class 4: Repeatable AI workflows without code
• Class objective: Design a multi-step workflow before automating it. Instructor-led content: Input, transformation, validation, output. Chaining prompts and reusing templates. Files and documents as context. Human approval points and handling failures. Hands-on work: Map a real workflow and run it by hand from start to finish. Student deliverable: Workflow diagram. Between-class practice: Decide which steps are safe to automate.

Topics covered

• Class 5: Development setup: VS Code, terminal, Python and an AI coding assistant
• Class objective: Run Python safely and see your goal working on your own computer. Instructor-led content: Installing Python and VS Code, or using an approved cloud environment. Files, folders, the terminal, the interpreter and scripts. print, input, comments and simple errors. Setting up an AI coding assistant, and the rule: understand every line you keep. Hands-on work: Write and run a first Python script. Run a ready-made script that calls an AI model, and change its prompt. Student deliverable: First Python program, plus the AI script running. Between-class practice: Repeat the setup in a clean practice folder.
• Class 6: Python essentials: values, conditions and loops
• Class objective: Use the core Python needed for AI applications. Instructor-led content: Strings, numbers, booleans, lists and dictionaries. if, elif and else. for loops and simple while loops. Reading error messages, and asking the coding assistant to explain them. Hands-on work: Build a small menu-driven program, writing the logic yourself and using the assistant only to explain errors. Student deliverable: Beginner Python exercise. Between-class practice: Practice types, conditions and loops.

Topics covered

• Class 7: Functions, files and JSON
• Class objective: Organize code and work with API-style data. Instructor-led content: Functions, parameters and return values. Reading and writing text and JSON. Dictionaries and lists as JSON-like structures. try and except for graceful errors. Hands-on work: Build helpers that save and load settings as JSON. Student deliverable: Python utility script. Between-class practice: Refactor earlier code into functions.
• Class 8: HTTP and APIs without fear
• Class objective: Understand how an application sends requests to a service. Instructor-led content: Client and server, request and response. GET and POST, headers and JSON bodies. API keys, environment variables and secrets. Status codes, rate limits and timeouts. Hands-on work: Call a training API and parse its JSON. Student deliverable: API request exercise. Between-class practice: Explain request, endpoint, key and response in your own words.

Topics covered

• Class 9: Your first AI API call
• Class objective: Send prompts from Python and handle the model's responses. Instructor-led content: How AI APIs and messages work, independent of provider. System, developer and user instructions. Choosing a model and response settings. Keeping credentials in environment variables. Hands-on work: Write, from scratch, a script that sends a prompt to the course's AI provider. Student deliverable: First AI-powered Python script. Between-class practice: Add handling for a missing key and a failed request.
• Class 10: Structured outputs and reliable application behavior
• Class objective: Make model output easy for software to validate. Instructor-led content: Structured and schema-based output. Parsing and validating JSON. Prompt constraints vs. checks in code. Retry and fallback strategies. Hands-on work: Request structured data, then validate it and reject malformed output. Student deliverable: Structured-output mini app. Between-class practice: Log invalid responses.

Topics covered

• Class 11: Build a simple AI chat application
• Class objective: Put the AI call behind an interface people can use. Instructor-led content: Streamlit or an equivalent beginner UI. Text input, buttons and displaying responses. Conversation history and state. Keeping the UI separate from the AI function. Hands-on work: Build a working chat UI with history. Student deliverable: Chat application v1. Between-class practice: Improve the layout and error messages.
• Class 12: Instructions, memory and conversation design
• Class objective: Control the application's behavior across many turns. Instructor-led content: System instructions and boundaries. History length and summarization. User preferences and memory. Handling ambiguous requests. Hands-on work: Add behavior rules and simple history trimming. Student deliverable: Chat application v2. Between-class practice: Test ten prompts and document the failures.

Topics covered

• Class 13: Tools and function calling
• Class objective: Let an AI application call safe program functions. Instructor-led content: Defining tools and functions. The model picks a tool, the application runs it, the result goes back to the model. Validation and allowlists. Never trusting generated arguments blindly. Hands-on work: Create calculator, date and data tools and add them to the app. Student deliverable: Tool-enabled assistant. Between-class practice: Validate one risky argument.
• Class 14: Connecting AI to real data and services, including MCP
• Class objective: Connect external data without giving the model uncontrolled access. Instructor-led content: REST APIs, databases and files as tools. The Model Context Protocol (MCP): what it standardizes and how an application uses an MCP server. Read-only vs. write actions. Authentication and permission boundaries. Logging every action. Hands-on work: Connect the app to a sample API or SQLite dataset. Connect it to one ready-made MCP server. Student deliverable: Data-connected assistant. Between-class practice: Document the access boundaries.

Topics covered

• Class 15: RAG fundamentals: grounding AI in documents
• Class objective: Understand retrieval-augmented generation before using frameworks. Instructor-led content: Why retrieval is needed for private or current content. Chunking, embeddings, and vector and keyword search. Retrieve, add to context, generate. Citations and "I don't know" answers. Hands-on work: Retrieve from a small document set and compare grounded and ungrounded answers. Student deliverable: RAG experiment. Between-class practice: Test questions that should return "not found".
• Class 16: Build a document Q&A application
• Class objective: Build a usable beginner RAG application. Instructor-led content: Ingesting and indexing documents. Retrieval settings and top-k. Prompting with retrieved context. Showing sources. Hands-on work: Build document Q&A that shows its sources. Student deliverable: RAG application v1. Between-class practice: Choose your capstone use case and write its success criteria in one page.

Topics covered

• Class 17: Agents: instructions, tools and controlled autonomy
• Class objective: Understand when an agent is the right choice. Instructor-led content: Model plus instructions plus tools plus a loop. Single-step vs. multi-step agents. Guardrails, budgets and stop conditions. Agents vs. fixed workflows. Hands-on work: Build a simple agent with two safe tools. Student deliverable: Simple agent. Between-class practice: Document one case where a fixed workflow is safer.
• Class 18: Automation workflows with AI
• Class objective: Combine AI with predictable automation. Instructor-led content: Trigger, action, validation and approval. Document and data automation examples. Scheduled and event-driven patterns. Human-in-the-loop checkpoints. Hands-on work: Build a classification or transformation automation with an approval step. Student deliverable: Automated workflow. Between-class practice: Add a path for low-confidence results, and sketch your capstone's architecture.

Topics covered

• Class 19: Multimodal AI: documents, images and audio
• Class objective: Use multimodal models appropriately inside applications. Instructor-led content: Understanding images vs. generating them. Extracting content from PDFs and documents. Speech input and output. Cost, speed and privacy implications. Hands-on work: Add one multimodal feature and compare clean and poor input. Student deliverable: Multimodal prototype. Between-class practice: Write limits and acceptance criteria for the feature.
• Class 20: AI data handling, databases and application state
• Class objective: Store application data without treating the model as the database. Instructor-led content: SQLite and basic relational storage. What to store vs. recompute. Personal data and retention. Logging requests and responses safely. Hands-on work: Save records to SQLite and build a history view. Student deliverable: Persistent AI app. Between-class practice: Mask sensitive fields in the logs.

Topics covered

• Class 21: Security, secrets, cost and rate limits
• Class objective: Prepare an AI application for real users. Instructor-led content: Environment variables and secret stores. Prompt injection and tool abuse. Rate limits, retries and cost tracking. Authentication and authorization basics. Hands-on work: Threat-model your capstone and add security and cost safeguards. Student deliverable: Security and cost checklist. Between-class practice: Test prompt-injection attempts against your app.
• Class 22: Evaluation, responsible AI and deployment
• Class objective: Measure whether the application is useful and safe, and get it running for others. Instructor-led content: Test sets and expected outputs. Quality, groundedness, speed and cost. Red-team thinking, transparency and escalation. Deployment options and environment configuration. Hands-on work: Create an evaluation set and score your capstone. Deploy a first version. Student deliverable: Evaluation report and a deployed capstone draft. Between-class practice: Choose three capstone improvements from the evaluation.

Topics covered

• Class 23: Capstone build and finishing
• Class objective: Turn your use case into a complete AI application. Instructor-led content: Checking the use case's boundaries and success criteria. Reviewing each student's UI, model, data and tools, storage and security. Hands-on work: Finish the capstone and run the acceptance tests. Student deliverable: Capstone application v1. Between-class practice: Fix the acceptance-test issues.
• Class 24: Capstone demo, failure testing and handover
• Class objective: Demonstrate a useful application and explain its limits. Instructor-led content: Failure and edge-case testing. Security and privacy review. Cost estimate and roadmap. Explaining the AI's behavior, data sources and the need for human checks. Next steps after the course. Hands-on work: Give the final demo and run adversarial and edge-case tests. Student deliverable: Final capstone and handover notes. Between-class practice: Final feedback.