Basics of Prompt Engineering: Introduction

What is Prompt Engineering

Key LLM Concepts

Basic Tips

Traditional vs Reasoning Models

Anatomy of a Prompt

Traditional Model Example

Prompting Reasoning Models

Reasoning Model Example

In this course, we'll take you through the basics of prompt engineering - looking at some high level concepts for prompting LLMs, the difference between traditional and reasoning models, and best practices for prompting both to ensure consistant results..

The Basics of Prompt Engineering

In this course, we teach you how to write effective prompts for Large Language Models (LLMs)—and why prompt engineering is quickly becoming one of the most valuable skills in the AI age. LLMs are powerful tools for reasoning, summarizing, generating, and coding, but their outputs are only as good as the prompts they’re given. Most people waste hours tweaking inputs without understanding why the model behaves the way it does. This course fixes that.

In just under two hours, we cover the foundational mechanics of how LLMs interpret prompts, the anatomy of a well-structured prompt, and how to adapt your approach depending on whether you're using traditional or reasoning models. You'll see real examples where we walk through prompts live, showing both what works and what breaks—and how to fix it.

It’s short, high-signal, and comes with copy-paste prompt templates, annotated examples, and real-world use cases you can apply immediately in your own projects—whether you're writing summaries, generating structured data, or integrating LLMs into your product stack.

It’s taught by Nick, a senior QA engineer and technical project manager who worked on Alexa at Amazon and has spent years translating abstract AI concepts into production-ready workflows. He’s taught thousands of students and consulted with teams deploying LLMs into everything from APIs to internal tools.

You don’t need to know code. You don’t need to understand math. You just need to understand the logic behind the prompt—and that’s what this course is built to teach you.

Whether you’re a developer, product manager, content strategist, or educator, prompt engineering is a core literacy for the new wave of AI tools. And this is the clearest, fastest way to get started.

Get Consistent Results from LLMs

In this course, we'll take you through the basics of prompt engineering - looking at some high level concepts for prompting LLMs, the difference between traditional and reasoning models, and best practices for prompting both to ensure consistant results.

Understand how LLMs interpret inputs by learning tokenization, context windows, and output limits to write more predictable, cost-efficient prompts.

Craft well-structured prompts using a clear framework of task, detail, tone, format, and context to reduce ambiguity and improve output quality.

Select the right model for the job by distinguishing when to use traditional vs. reasoning models based on task complexity and performance tradeoffs.

Improve output consistency and reduce hallucinations by applying structured formatting, clear language, and example-driven prompting techniques.

Watch real-world prompt demos through side-by-side examples that show how different models process the same task and why prompt design matters.

Build AI-native communication skills that are becoming essential across product, engineering, content, and research roles in the AI-driven workplace.

Large Language Models (LLMs) are not all built the same. Understanding the difference between traditional and reasoning models is essential for selecting the right tool—and prompt style—for your task. This module breaks down how these two model types work, why their behavior differs, and when each is appropriate.

Traditional LLMs operate on a straightforward principle: they take a prompt, process it once, and return a single prediction, token by token. The process is linear and probabilistic—words are generated based on the most statistically likely next token.

Fast responses

Lower computational cost

Simple generation tasks (e.g., summaries, rewrites, completions)

They’re ideal when speed, simplicity, and cost are priorities—and when the task doesn’t require deep logical reasoning or intermediate steps.

---
title: Traditional vs Reasoning Models
privateVideoUrl: https://stream.mux.com/v6TuMIOFShYdQXgasngesLotrLP00oZiqATEjGeMSY7s.m3u8
isPublicLesson: true

---

Large Language Models (LLMs) are not all built the same. Understanding the difference between traditional and reasoning models is essential for selecting the right tool—and prompt style—for your task. This module breaks down how these two model types work, why their behavior differs, and when each is appropriate.

# Traditional Models

Traditional LLMs operate on a straightforward principle: they take a prompt, process it once, and return a single prediction, token by token. The process is linear and probabilistic—words are generated based on the most statistically likely next token.

These models excel in:

    Fast responses

    Lower computational cost

    Simple generation tasks (e.g., summaries, rewrites, completions)

They’re ideal when speed, simplicity, and cost are priorities—and when the task doesn’t require deep logical reasoning or intermediate steps.

Nick Badot

So going to traditional versus reasoning models,

most mainline LLMs have both as part of their product offering.

with more traditional models and then up to 3.0 reasoning

Most mainline models will have a couple of different options.

And why it pays off the prompt differently

is that instead of taking in your input string,

doing its black box, mathematics, statistical magic

it's instead of just predicting a string of words,

it's actually analyzing the prompt you put in,

splitting that up into multiple different steps,

each of which is its own separate LLM call.

But at a higher level, that's basically what's happening.

And this is called chain of thought or COT.

And it's in a lot of ways the same technology, right?

to imitate a little bit more the way a human does deductive

And in a lot of cases, this does get you better results,

because you have this workflow that has multiple steps,

but will parse things in a more methodical manner

Obviously, because this is much more computationally expensive

and because results are better in a lot of cases,

reasoning models tend to be more expensive.

So I tend to only use them when I think they'll actually add

value for a lot of kind of more simple use cases,

traditional models are still the way to go.

And obviously, if this is being integrated

using reasoning models can really slow you down.

So it really is a matter of picking the right tool

for the job, and that is going to be driven by context.