This lecture provides an overview of the Tools and Local Setup section.

This lecture covers the setup of the correct Python version required for the course using pyenv. By the end, you will have Python 3.13.3 installed and set as the local version for the project directory.

This lecture provides updates for fully activating the OpenAI Platform account before starting to use it.

This lecture guides you through creating an OpenAI account, setting up a new project, and generating a secret API key. You will learn how to store this key securely in a local .env file for authentication.

This lecture presents Anthropic as an alternative to OpenAI, highlighting its initial free credits. You will learn how to create a workspace, generate an API key, and store it in the .env file.

This lecture provides the detailed steps taken to setup your Python and Local Environment to make the most of the course.

This lecture highlights how we will use GitHub Copilot for the course project implementation, and discusses important cost considerations.

This lecture details the process of setting up a local Python virtual environment and installing the course dependencies from the requirements.txt file. You will learn how to activate the environment and launch JupyterLab to ensure all libraries are correctly loaded.

This lecture focuses on authenticating with the OpenAI API by securely loading your API key from a .env file. You will learn how to instantiate the OpenAI client and handle potential AuthenticationError exceptions.

This lecture guides you through making your first API call to the OpenAI chat.completions.create endpoint. By the end, you will understand how to structure the model and messages parameters and parse the response object to display the generated text.

This lecture introduces LiteLLM, an open-source tool that provides a unified, OpenAI-compatible interface for calling over 100 different LLM providers. You will learn how to refactor a standard OpenAI API call to use the litellm.completion function, simplifying multi-provider integrations.

This lecture demonstrates the power of LiteLLM by showing how to call an Anthropic model with minimal code changes. You will learn how to programmatically discover valid model names for a given provider and use them to seamlessly switch between different LLMs.

This lecture provides a detailed exploration of the chat completion response object, covering key metadata like the request ID and model used. You will learn how to inspect the usage attribute to understand token consumption and how to generate multiple response choices using the n parameter.

This lecture introduces two critical API parameters for controlling model output: temperature and max_tokens. You will learn how to use temperature to adjust the model's creativity and max_tokens to set a hard limit on the response length for cost and performance control.

This lecture presents important code changes necessary for compatibility with the latest GPT-5 models launched by OpenAI, especially for the max_tokens parameter.

This lecture continues the exploration of API parameters, covering the stop sequence, the n parameter for multiple choices, and the response_format type. You will learn how to use response_format to guarantee the model returns a valid JSON object, a critical feature for building reliable applications.

This lecture explains how to implement streaming to improve user experience by receiving response tokens as they are generated. You will learn to use the stream=True parameter, which returns a generator that you can iterate over to display the output in real-time.

This lecture guides you through how to run local LLMs with Ollama, and how to interact with them using litellm.completion. You will learn the necessary steps to install Ollama, pull LLM models, run them locally, as well as the necessary code changes in litellm to make it work with Ollama.

This lecture demonstrates how to use GitHub Copilot as a coding agent to scaffold a complete Python library project. You will learn to write effective prompts to generate a modern project structure, including the pyproject.toml file, and refine generated files like .gitignore.

This lecture provides a detailed walkthrough of the standard Python project structure generated by GitHub Copilot. You will understand the purpose of key files and directories like src, tests, pyproject.toml, and the license file.

This lecture covers the implementation of a minimal command-line interface (CLI) using the Click library and GitHub Copilot. You will learn how to define command groups, add commands, configure script entry points in pyproject.toml, and write basic unit tests for your CLI.

This lecture focuses on integrating AI capabilities into the CLI tool by replacing a static string with a dynamic response from an LLM. You will learn to use LiteLLM to call the OpenAI API, manage dependencies, and handle potential authentication errors within the application.

This lecture teaches you how to write robust unit tests for AI-powered code by mocking external API calls. You will learn to use the pytest-mock fixture to patch the litellm.completion function, ensuring your tests are stable, and adapt them to support streaming responses.

This lecture introduces tokenization as the fundamental process by which LLMs understand and process text. You will learn why understanding tokens is critical for managing costs, context windows, and model behavior.

This lecture provides a hands-on guide to tokenization using OpenAI's tiktoken library. You will learn how to load a model-specific tokenizer and use it to encode text into token IDs and decode them back into readable strings.

This lecture continues the exploration of tokenization by examining how complex words and code snippets are handled. You will see how uncommon words are broken into smaller sub-word tokens and how code is processed just like any other text.

This lecture explains the concept of log probabilities (log_probs) and why LLMs use them instead of plain probabilities. You will understand how log_probs help avoid numerical underflow and how to convert them back to percentages to reason about a model's token choices.

This lecture visualizes how LLMs generate responses token-by-token using streaming and log probabilities. You will learn to inspect the log_probs parameter to see the statistical path the model takes and understand its certainty when choosing the next token.

This lecture defines the concept of a "context window," the hard limit on the number of tokens an LLM can process at once. You will learn what contributes to the context window and compare the different window sizes across popular models.

This lecture breaks down the pay-per-token pricing model used by most LLM providers. You will learn the formula for calculating API call costs and understand how costs accumulate in a multi-turn conversation as the conversation history grows.

This lecture provides a practical guide to calculating the cost of a single API call using Python. You will learn to create a helper function that pulls token counts from the API response's usage object and applies model-specific pricing to determine the exact cost.

This lecture demonstrates the cumulative nature of costs in a multi-turn conversation. Through a simulated dialogue, you will see how the input token count grows with each turn, making later API calls progressively more expensive.

This lecture categorizes different LLMs based on key dimensions like core capabilities, modality, context window size, latency, and cost. You will learn how to compare models and select the right one for a specific task beyond just picking the most powerful option.

This lecture clarifies the distinct functions of the system, user, and assistant roles in a chat completion prompt. You will learn when to use each role to effectively set context, ask questions, and provide examples.

This lecture demonstrates the power of the system prompt for controlling an LLM's behavior with high precision. You will build a specialized assistant that generates conventional commit messages and see how system instructions take precedence over conflicting user requests.

This lecture introduces the three foundational components of any effective prompt: a clear Instruction, relevant Context, and specific Constraints. You will learn why balancing these three pillars is the most critical skill for achieving reliable and high-quality model outputs.

This lecture applies the Instruction-Context-Constraint framework to the practical task of generating unit tests for a Python function. You will see how iteratively adding each component dramatically improves the quality and relevance of the generated code.

This lecture explains how to use delimiters like markdown headers, XML-style tags, and triple backticks to structure prompts effectively. You will learn how delimiters improve clarity and reliability for both humans and LLMs by creating clear, logical sections.

This lecture contrasts a poorly structured, wall-of-text prompt with a revised, well-delimited version to highlight common pitfalls. You will learn how clear structure solves problems like vague instructions, ambiguous output requirements, and missing business logic.

This lecture provides a hands-on demonstration of using different delimiters—markdown headers, XML tags, and triple backticks—to achieve the same goal. You will learn to apply these techniques to structure a prompt that summarizes a bug ticket, making the prompt easier to read and the model's task clearer.

This lecture introduces the Persona Pattern, a technique where you instruct the model to adopt a specific role, such as a Product Manager or QA Engineer. You will learn how assigning a persona drastically changes the focus, tone, and technical depth of the model's response.

This lecture puts the Persona Pattern into practice by having an LLM review an implementation plan, first with a generic prompt and then as a "Senior Cloud Architect." You will also learn how to use one LLM to generate a detailed and reusable persona description for another.

This lecture demonstrates how to enhance the Persona Pattern by adding specific behavioral rules that define how the persona should act. You will learn to guide the model's analysis by specifying risk assessment criteria, tone, and a required output structure.

This lecture provides another advanced example of combining the persona and behavioral patterns to create an expert "Principal Database Engineer." You will see how this highly specific prompt elicits a detailed and thorough review of a complex database migration plan.

This lecture explains the concepts of zero-shot and few-shot prompting. You will learn that while modern models excel at zero-shot tasks, providing a few high-quality examples (few-shot) is a powerful technique for enforcing specific output formats and teaching nuanced behavior.

This lecture provides a hands-on comparison between zero-shot, few-shot, and zero-shot with explicit business rules for generating structured JSON. You will learn that while few-shot prompting enforces a schema, providing clear, structured rules in a zero-shot prompt is often a more direct and effective approach.

This lecture explores several techniques for controlling an LLM's output format, starting with the simple "please method." You will then apply the few-shot prompting pattern and the template pattern to guide the model toward producing a consistent JSON object from a user review.

This lecture covers the most robust methods for guaranteeing structured output: defining a clear schema within the prompt and using API-level enforcement. You will learn to combine a custom, human-readable schema with the response_format: json_object parameter to get reliable, parsable JSON every time.

This lecture introduces the Chain of Thought (CoT) pattern, a technique for prompting a model to "think step-by-step" before providing an answer. You will learn how CoT improves performance on complex reasoning tasks and provides transparency into the model's problem-solving process.

This lecture demonstrates the practical application of zero-shot Chain of Thought prompting for a code refactoring task. You will see how adding the simple phrase "Let's think step by step" prompts the model to provide its reasoning before presenting the final refactored code.

This lecture introduces the Template Pattern, a powerful method for getting structured, machine-parsable output instead of conversational text. You will learn how to define a template with custom delimiters to separate the model's reasoning from the final answer, eliminating the need for unreliable string parsing.

This lecture provides a hands-on demonstration of the Template Pattern to solve a code refactoring task. You will learn how to create a template with custom tags (e.g., <thoughts>, <refactored_code>) and instruct the model to fill it, resulting in a perfectly structured and easily parsable response.

This lecture kicks off the project by using a GitHub Copilot agent to scaffold the boilerplate code for a new commit command. You will learn to write a prompt that instructs the agent to create the necessary file, add the Click command structure, and register it with the main CLI application.

This lecture focuses on implementing the core logic for retrieving staged code changes from Git. You will instruct an AI agent to write a Python function that executes the git diff --staged command and to create a corresponding suite of unit tests that mock the subprocess call.

This lecture guides you through the process of creating a sophisticated "master prompt" template for generating conventional commit messages. You will use an AI agent in edit mode to generate the prompt, then manually refine it to include clear instructions, examples, and robust XML delimiters.

This lecture wires all the pieces together to create the first end-to-end version of the AI commit functionality. You will learn to use an AI agent to connect the git diff retrieval, prompt formatting, LLM API call, and user confirmation flow that commits the code using subprocess.

This lecture enhances the user experience by implementing an interactive feedback loop. You will learn to add an "Approve, Adjust, Abort" choice, allowing the user to provide feedback and receive a refined commit message from the LLM.

This lecture focuses on creating a robust and comprehensive test suite for the interactive commit command. You will use an AI agent to generate tests covering the approve, abort, and adjust workflows, mocked LLM interactions, and various error conditions.

This lecture demonstrates how to add structured logging to the CLI application for better debugging and observability. You will use an AI agent to implement a --verbose flag that controls the log level and add context-rich log statements throughout the commit command's execution path.

This lecture refactors the hardcoded model name into a dynamic CLI option. You will learn how to add a --model flag to your Click application and update the test suite to correctly pass the necessary context during test runs.

This lecture concludes the project by using an AI agent to generate comprehensive documentation. You will learn to write a simple prompt that instructs the agent to create documentation files and update the project's main README.md file based on the implemented features.

This lecture introduces the "Flip the Script" pattern, which forces the AI to ask clarifying questions instead of immediately providing a solution. You will learn how to use this technique to handle ambiguous tasks, such as designing a user authentication system, turning the AI into a proactive partner.

This lecture continues exploring the "Flip the Script" pattern by applying it to open-ended problems where multiple solutions exist. You will learn how to prompt the model to list and explain various options, such as different database technologies, and then ask for your input on how to proceed.

This lecture introduces the Prompt Generator pattern, where a powerful LLM is used to create high-quality, optimized prompts for other, potentially simpler models. You will learn to craft a "master prompt" that defines the rules and process for this interactive prompt-generation session.

This lecture demonstrates how to implement an interactive conversation loop in Python to collaboratively build a prompt with an AI. You will see how the AI uses the master prompt to ask clarifying questions about a task and then generates a final, optimized system prompt based on your answers.

This lecture explains the Decomposition pattern, a technique for breaking down a complex task into a sequence of smaller, manageable subtasks. You will learn how to create a multi-prompt pipeline to first identify bugs in code, then refactor the code, and finally generate unit tests for it.

This lecture introduces the Self-Critique (or Self-Correction) pattern, which mimics the human process of iterative refinement. You will learn how to prompt a model to generate a first draft of a solution and then, in a second step, ask it to criticize and improve its own work.

This lecture introduces Function Calling, a mechanism that allows LLMs to interact with external tools and APIs. You will learn how to define a Python function and create a corresponding JSON schema that describes its purpose and parameters for the LLM.

This lecture completes the function calling workflow by showing how to execute the tool requested by the LLM and return the result. You will learn to append the tool's output to the conversation history and make a final API call to get a human-readable summary.

This lecture introduces the Self-Consistency pattern, beginning with the "divergence" phase for creative tasks. You will learn to prompt the model to generate multiple, diverse solutions—in this case, three different docstrings for a function—by using a higher temperature and setting n=3.

This lecture covers the "convergence" or synthesis phase of the Self-Consistency pattern. You will learn how to feed all the previously generated drafts into a second "editor" prompt that instructs the model to combine the best elements into a single, superior final version.