Core Insights from Andrew Ng's Prompt Engineering Course: From Fundamentals to Practice

Course Background and Positioning

The "ChatGPT Prompt Engineering for Developers" course, co-created by Andrew Ng and OpenAI's Iza Fulford, has a very clear positioning — it's not about memorizing "30 must-know prompts" or other internet fast-food content. Instead, it's designed for developers, teaching how to rapidly build software applications by calling Large Language Models (LLMs) through APIs.

At the very beginning, Andrew Ng points out a severely underestimated fact: the potential of LLMs as developer tools is far from fully tapped. His team at AI Fund has collaborated with numerous startups to apply LLM technology across various scenarios, witnessing firsthand how LLM APIs enable developers to build applications at remarkable speed. AI Fund, founded by Andrew Ng in 2017, is an AI startup incubation fund that adopts a unique "studio model" — providing not just capital, but deep involvement in building companies from scratch, including technology selection, team assembly, and product direction. This deep involvement gives Andrew Ng first-hand observations and insights into how LLMs land in real business contexts, making this course's content much closer to real engineering practice rather than pure theoretical discussion.

The Essential Difference Between Two Types of LLMs

The course first clarifies a key concept: large language models fall into two major categories — Base LLMs and Instruction Tuned LLMs. Understanding this distinction is a prerequisite for mastering prompt engineering.

Base LLM: A Pure Text Predictor

The training objective of a Base LLM is to predict the next word based on existing text. Trained on massive internet data, it learns "what is most likely to come next."

For example:

• Input: "Once upon a time, there was a unicorn" → It continues with "that lived in a magical forest with all her unicorn friends"
• Input: "What is the capital of France?" → It might output "What is France's largest city? What is the population of France?"

The latter seems absurd but is perfectly logical — because the internet is full of quiz-style lists about France, and the Base LLM is simply doing statistically driven "continuation." This reveals the fundamental limitation of Base LLMs: they are samplers from a probability distribution, not conversational agents that understand intent. They don't know you're "asking a question" — they only know how to predict the most likely token sequence to follow the given text based on statistical patterns in the training data.

Instruction Tuned LLM: An AI Assistant That Can Actually Converse

The training path for an Instruction Tuned LLM is: first train a base model on massive data, then perform Supervised Fine-Tuning (SFT) using "instruction–high-quality response" paired data, and finally further optimize through RLHF (Reinforcement Learning from Human Feedback) to make it better at following instructions.

RLHF is the key technology that evolves large language models from "being able to talk" to "talking like a human." Its core process has three steps: first, fine-tune the base model on human-annotated high-quality instruction-response pairs using supervised learning; second, train a Reward Model by having human annotators rank multiple model outputs, allowing the reward model to learn human preferences; finally, use reinforcement learning algorithms like PPO (Proximal Policy Optimization) to further optimize the language model's output strategy using the reward model's scores as signals. This technique was systematically introduced by OpenAI in the InstructGPT paper and is the core technical foundation enabling ChatGPT's natural conversational abilities.

These models are trained to be Helpful, Honest, and Harmless, significantly reducing the probability of generating toxic content. These three principles are commonly known as the "3H Principles" or "HHH Framework," first systematically articulated by Anthropic in their AI safety research, and have since become the industry standard for evaluating and training AI assistants. It's worth noting that tension can exist between these three goals — for example, excessive pursuit of "harmless" may cause models to refuse reasonable questions (the "over-alignment" problem), and how to balance the three remains an active research topic. Andrew Ng explicitly recommends: for the vast majority of practical applications, developers should focus on Instruction Tuned LLMs.

Two Core Principles of Prompt Engineering

Principle 1: Make Instructions Clear and Specific

Andrew Ng proposes a highly practical mental model: Think of the LLM as a smart person who knows nothing about your specific task. When an LLM performs poorly, it's often not because the model lacks capability, but because the instructions aren't clear enough.

Take "Write a paragraph about Turing" as an example. The problems with this instruction include:

• No specified focus (scientific achievements? personal life? historical role?)
• No specified tone (professional press release? or casual chat between friends?)
• No reference materials provided

A better approach is to assign the task as if you were briefing a fresh college graduate: tell them what to focus on, what style to write in, and even provide some reference materials upfront. It's especially important to emphasize that "clear" does not mean "short." Many developers mistakenly believe good prompts should be as concise as possible, but in reality, a longer prompt with detailed context, explicit constraints, and output format requirements often performs far better than a vague short one. In API call scenarios, the cost of prompt length is far lower than the time cost of repeated retries.

Principle 2: Give the LLM Sufficient Thinking Time

The course's second core principle is to give the model "thinking time." This corresponds to prompting techniques like Chain-of-Thought (CoT) — rather than expecting the model to produce the answer to a complex problem in one shot, guide it to reason step by step.

The Chain-of-Thought prompting technique was formally introduced by Jason Wei and colleagues from the Google Brain team in their 2022 paper Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. The research found that simply adding a guiding phrase like "Let's think step by step" to the prompt, or providing a few examples that include reasoning processes (Few-shot CoT), can dramatically improve LLM performance on mathematical reasoning, commonsense reasoning, and symbolic reasoning tasks. This finding reveals an important insight: LLMs don't lack reasoning ability — they need to be properly "activated." Subsequent research has spawned more advanced reasoning strategies such as Tree-of-Thought and Self-Consistency, forming an active research direction.

This principle is especially critical when handling mathematical calculations, logical judgments, and multi-step tasks — by requiring the model to "list the steps first, then give the conclusion" in the prompt, you can significantly improve output accuracy. From a technical perspective, this works because in the Transformer architecture, each token's generation depends on attention computation over all preceding tokens. When the model is asked to output intermediate reasoning steps first, those steps themselves become "working memory" for subsequent reasoning, thereby reducing the probability of errors that occur when jumping directly to the final answer.

Course Content Architecture

The full course covers the following core modules:

1. Prompt Best Practices: Systematic methodology for software development
2. Common Use Cases: Summarizing, Inferring, Transforming, Expanding
3. Hands-on Project: Building a chatbot using LLMs

The categorization of these four use cases elegantly covers the core capability dimensions of LLMs in application development: Summarizing corresponds to information compression (e.g., distilling long documents into summaries); Inferring corresponds to information extraction and analysis (e.g., sentiment analysis, topic identification); Transforming corresponds to format and language conversion (e.g., translation, code conversion, tone adjustment); Expanding corresponds to content generation (e.g., generating a complete email from brief bullet points). Understanding this classification framework helps developers quickly identify which prompting strategy to use when facing specific business requirements.

This course structure — from principles to applications to hands-on practice — forms a complete learning loop. Each module comes with runnable Jupyter Notebook code examples, allowing developers to verify results directly through practice. As the de facto standard tool for AI/ML development, Jupyter Notebook's interactive workflow of "write a bit, run a bit, review a bit" is highly aligned with the iterative nature of prompt engineering — developers can debug prompts cell by cell, instantly view API responses, and rapidly iterate, which is far more efficient than writing complete programs in a traditional IDE before running them.

Core Takeaways for Developers

The value of this course lies not only in technical details but also in a shift in mindset. The core message Andrew Ng repeatedly emphasizes is: Prompt engineering is not about "memorizing templates" — it's a systematic communication design skill.

For developers, the key cognitive shifts include:

• Moving from "one-off use of the ChatGPT web interface" to "building reusable applications through APIs" — this means prompts are no longer ad-hoc sentences typed on the fly, but engineering assets that need to be version-controlled, tested, and optimized like code. In production environments, a single prompt template may be called millions of times, and its quality directly impacts product experience and cost efficiency.
• Moving from "trial-and-error prompting" to "principled prompt design" — the two principles provided by the course (be clear and specific, give thinking time) form a reusable design framework, transforming prompt optimization from random trial-and-error into systematic, directional improvement.
• Moving from "treating LLMs as search engines" to "treating LLMs as programmable reasoning engines" — search engines retrieve existing information, while LLMs can understand context, perform transformations, and generate new content. This cognitive difference determines whether developers can truly unlock the application potential of LLMs.

As model safety and alignment continue to improve, Instruction Tuned LLMs are becoming increasingly easy to use. Mastering prompt engineering is essentially mastering the universal interface for efficient collaboration with this generation of AI systems — regardless of how the underlying models evolve, the ability to clearly express intent and structurally decompose tasks will always be a core competitive advantage.

Key Takeaways