Master Prompt Engineering: From Random Chat to Precise Control with Zero-shot, Few-shot, and Chain‑of‑Thought

Introduction

The article shows why interacting with large language models (LLMs) can feel unpredictable and how the right prompting techniques turn the interaction into a reliable development tool.

Zero-shot Prompting

Concept: Issue a command without providing any examples. It is the most common way to use an LLM.

Frontend analogy: Calling a function with only arguments, no callbacks or configuration.

// Zero-shot
gotoSubmit("Submit");

Applicable scenarios: General knowledge questions such as “Explain what Vue framework is.”

Limitations: For complex tasks the model may “free‑run,” producing output that does not follow the desired format.

Prompt: Write a React button component. AI response: The answer may vary between class and functional components, inline styles or CSS modules, and the output format is uncontrolled.

Few-shot Prompting

Concept: Provide one or more input‑output examples in the prompt so the model can imitate the pattern.

Frontend analogy: Writing unit tests or Storybook documentation that specify “when input A, output B.”

// Few-shot
expect(transform('red')).toBe('#ff0000');
expect(transform('blue')).toBe('#0000ff');
// Now transform 'green'

The model then produces results that match the demonstrated pattern.

Why it works: LLMs are text‑completion engines; they capture the pattern (e.g., JSON structure, code style) from the examples and apply it to new inputs.

Prompt: Generate Tailwind class names from a description. Example 1 – Input: red background, rounded, padding 4 → Output: bg-red-500 rounded p-4 Example 2 – Input: large bold blue text → Output: text-lg font-bold text-blue-500 Task: Input – absolute positioning, centered, semi‑transparent black background → ?

Chain of Thought (CoT) Prompting

Concept: Ask the model to show its reasoning before giving the final answer, e.g., “Let’s think step by step.” This forces the model to perform additional computation and keep intermediate results in context.

Frontend analogy: Adding comments or using a debugger to print intermediate variables during complex function execution.

// CoT
function controlNextCalc(data) {
  // 1: filter data...
  // 2: reassemble...
  // 3: return new data...
  return result;
}

Why it works: The linear nature of LLM computation means that providing explicit reasoning steps gives the model more processing time and context, improving accuracy, especially for math or logic problems.

Practical Exercise: Generating Structured JSON with DeepSeek

Goal: From a natural‑language description, produce a JSON schema for a dynamic front‑end form.

Common pitfall (Zero‑shot): The model often returns JSON with comments, Chinese field names, or structures that do not match the component library, leading to JSON.parse() failures.

Prompt: Generate a JSON config for a user registration form with username and password. Result: The output contains comments, non‑standard field names, or an incorrect hierarchy (illustrated by three screenshots in the original article).

Successful approach (Few‑shot + CoT + Constraints):

# Role
You are a senior front‑end architect focusing on low‑code schema design.
# Context
Generate a JSON schema for rendering a dynamic form based on user description.
# Constraints
1. Output valid JSON only, no extra code fences.
2. No comments.
3. Field type must be one of 'input' | 'select' | 'checkbox' | 'date'.
4. Include label, key, required fields.
# Few-shot Examples
User: "Create a form with name and gender."
AI:
[
  {"key":"name","label":"姓名","type":"input","required":true},
  {"key":"gender","label":"性别","type":"select","options":["男","女"],"required":true}
]
# Task
User: "Generate an activity registration form with name (required), date (required), participant count (optional), and pickup option (optional)."
# Chain of Thought
Think about each field's type and key, then output pure JSON.

Expected output (DeepSeek):

[
  {"key":"activityName","label":"活动名称","type":"input","required":true},
  {"key":"activityDate","label":"活动时间","type":"date","required":true},
  {"key":"participantCount","label":"参与人数","type":"input","required":false},
  {"key":"needPickup","label":"是否需要接送","type":"checkbox","required":false}
]

The article then analyses the prompt components:

Role: Sets a professional persona, guiding the tone of the output.

Constraints: Enforces a strict type system to prevent hallucinations.

Few-shot: Provides a concrete example that locks the JSON array structure.

CoT: Encourages internal logical verification before emitting the final JSON.

Conclusion

To make LLMs obey precise instructions, treat them as senior programmers who need detailed documentation and test cases. Use Zero‑shot for quick probes, Few‑shot to define format, and Chain‑of‑Thought to improve logical correctness. Mastering these core prompting techniques is essential for reliable AI‑assisted development.