The gap between a Claude Code user who gets 2x productivity and one who gets 10x is entirely in the prompts. There's a craft here — specificity, context, scope, constraints. Master it and Claude becomes your engineering team.
Learning Objectives
After this lesson, you will be able to:
Write specific, detailed prompts that get the right result on the first try
Structure a CLAUDE.md file that teaches Claude Code your project's rules and patterns
Use plan mode when you need Claude Code to think before it acts on big tasks
Break large tasks into smaller, clear subtasks that Claude Code can handle reliably
This lesson is possibly the highest-ROI lesson in the entire track. The difference between a vague prompt and a great prompt is the difference between 5 minutes of iteration and getting it right the first time. The patterns here will make every future Claude Code interaction faster.
Your Reflection
Saves automatically
What’s one thing you learned? What’s still confusing?
Vague vs Specific Prompts — See the DifferenceInteractive
Loading visualization...
What Do You Think?
Which prompt will produce better results from Claude Code?
Try it! Take a task you recently did manually in your code. Write two versions of the prompt: a vague one ("fix the bug") and a specific one (with the file name, the error, the expected behavior). Run the specific one in Claude Code and notice how it nails the task on the first try. Save the specific prompt as a template for next time.
Be specific about what you want. "Fix the bug" is not a task description -- it is a hope. "The signup form allows passwords shorter than 8 characters, which violates the requirement in auth-spec.md" is a task description.
Claude Code can search your entire codebase, but telling it where to look saves time and reduces errors. "The issue is in src/auth/validate.ts" prevents Claude Code from looking in the wrong places.
Tell Claude Code what patterns to follow, what to avoid, and what conventions to respect. "Follow the existing error handling pattern in the other controllers" or "Use the cn() utility for conditional classes, not template literals."
For tasks that affect multiple files or involve architectural decisions, use plan mode first:
> Plan how you would add WebSocket support for real-time notifications.
> Don't write any code yet -- just outline the approach.
Claude Code will produce a plan listing:
Which files need to change
What new files need to be created
The order of operations
Potential risks or breaking changes
Review the plan, adjust if needed, then say "Execute the plan."
What Do You Think?
You want Claude Code to build a complete user authentication system with registration, login, password reset, and email verification. Should you give this as one prompt or break it down?
The best approach is plan mode first, then phased execution. A single prompt for the entire auth system risks context overflow and makes it hard to review changes. Four completely separate prompts loses the architectural coherence. Plan mode gives you the big picture, then you can execute in logical phases ("First, build the registration flow. Then, add login."), with each phase building on the previous one.
Specific prompts get specific results -- always include WHAT (the task), WHERE (the files), HOW (the constraints), and VERIFY (the check) in your prompts
CLAUDE.md is your highest-ROI investment -- a well-crafted project instruction file prevents the most common mistakes across every interaction with Claude Code
Plan mode before complex tasks -- see the full plan before any code is written, then execute in phased increments
Break large tasks into small, testable subtasks -- each subtask should produce a working increment that builds on the previous step
What is the most important component of an effective Claude Code prompt?
Quick check
Pick the prompt most likely to give a correct, ready-to-merge result on the first try.
This four-part pattern — WHAT / WHERE / HOW / VERIFY — is the cliff-notes version of prompt engineering for agentic systemsPrompt EngineeringPrompt engineering crafts input text to steer a language model's output through techniques like zero-shot, few-shot, and chain-of-thought prompting.Learn more →: every token you spend specifying intent is a token Claude doesn't have to guess on.
You now know how to write prompts that get results on the first try. Next up: Code Generation -- using Claude Code to build features, APIs, components, and tests from natural language descriptions.