Most people who struggle with Claude Code aren’t struggling because the AI is bad — they’re struggling because they’re treating it like a search engine. Prompt engineering is the skill that closes that gap. It’s not complicated, and you don’t need a computer science background to get good at it. Here’s what actually matters.
What Prompt Engineering Actually Is
Prompt engineering is just communicating clearly with an AI. That’s it. The phrase sounds technical but the underlying skill is familiar: when you brief a contractor, write a design spec, or explain a task to a new colleague, you’re doing the same thing — giving context, setting expectations, and describing the outcome you want.
The difference with Claude Code is that the stakes for clarity are higher. A vague brief to a human gets a follow-up question. A vague prompt to Claude Code gets a confident, plausible answer that solves the wrong problem.
Good prompt engineering means your first output is useful, your corrections are targeted, and your total back-and-forth is short.
The Most Important Concept: Context is Everything
Claude Code has no memory of your project unless you tell it. Every session starts blank. The model is smart enough to fill in gaps — but what it fills them in with is its training data, not your actual requirements.
The single biggest improvement most beginners can make is to provide more context upfront.
Instead of:
Build me a contact formTry:
Build a contact form for a B2B SaaS product.
Fields: name, company, email, message.
On submit, show an inline success message — no page redirect.
Style it to match the existing Tailwind components in /components/ui.The second prompt takes 15 seconds longer to write and produces output that’s dramatically closer to what you want.
The Four Elements of a Strong Prompt
1. Goal — What you want to end up with
Be specific about the output, not the process. “Create a button component” is better than “write some React code.” “Refactor this function to be more readable” is better than “fix this.”
2. Context — What Claude needs to know to do it right
This is where most prompts break down. Context includes:
- Tech stack: “We’re using Next.js App Router with TypeScript”
- Where the output lives: “This goes in
/components/forms/” - Existing patterns to follow: “Match the pattern in
/components/Button.tsx” - What the user is doing: “This is on the checkout page — the user has already entered their card details”
3. Constraints — What to avoid
Constraints narrow the solution space before Claude starts writing. Without them, the model makes reasonable choices that may not match yours.
Examples:
- “Don’t install new packages — use what’s already in
package.json” - “Keep the function under 40 lines”
- “No inline styles — Tailwind only”
- “Don’t change the existing API interface”
4. Output format — What the response should look like
If you want a file, say so. If you want a code snippet only (no explanation), say so. If you want three options to choose from, ask for three options.
Give me just the updated function — no explanation needed,
I'll review the diff myself.Iteration: Correcting Without Starting Over
When Claude Code gets something wrong, how you respond matters. Vague corrections produce vague fixes.
Weak correction:
That's not right, try againStrong correction:
The modal closes when I click inside it, not just when I click outside.
The click handler needs to stopPropagation on the inner content div.The second tells Claude exactly what’s wrong and points at the cause. It’s faster to be specific than to watch the model guess its way to the answer over three rounds.
A useful mental model: imagine you’re leaving a code review comment. A good review comment names the problem, explains why it’s a problem, and optionally suggests the fix. Do the same with your corrections.
Ask Claude to Ask You Questions
One of the most underused techniques is letting Claude drive the clarification. Before starting a complex build, try:
I want to build a booking system for a small gym.
Before you write any code, ask me everything you need to know
to do this properly.Claude will surface questions you hadn’t thought to answer: Do members book classes or equipment? Can a time slot be double-booked by different members? What happens if a class is cancelled?
This front-loads the thinking before any code is written, which is cheaper than discovering constraints halfway through a build.
One Task at a Time
Claude Code works best when tasks are scoped tightly. The temptation with a capable AI is to dump everything into one prompt. Resist it.
Too broad:
Build a full user authentication system with login, signup,
password reset, OAuth via Google, session management, and
an admin panel to manage usersBetter:
Start with the signup flow only — email and password,
no OAuth yet. Use Supabase Auth.
I'll tell you when to move to the next part.Breaking it up gives you checkpoints where you can verify the output before Claude builds on top of it. A bug caught after step 1 is cheap. A bug discovered after step 5 means reviewing five layers of generated code.
Use Examples to Show What You Mean
When words aren’t enough, show Claude an example of what you’re after.
Rewrite this error message to match this tone:
Current: "Error: invalid input"
Target tone: "Hmm, that doesn't look right —
email addresses usually have an @ in them."You can also paste in an existing component and ask Claude to match its pattern:
Here's our existing Card component:
[paste code]
Build a ProfileCard using the same prop structure and
Tailwind class naming conventions.Examples are faster than lengthy descriptions. Show, don’t just tell.
When to Start a New Conversation
Claude Code’s context window is long, but long conversations introduce drift — where earlier decisions get overridden by later ones, or the model loses track of constraints you set 50 messages ago.
A rough rule: start a new session when:
- You’ve finished one feature and are starting a different one
- The conversation has gone sideways and corrections aren’t landing
- You’re switching from building to debugging (or vice versa)
At the start of a new session, re-establish the context that matters:
Context: I'm working on a Next.js 15 project using Supabase and Tailwind.
We've already built user auth and a dashboard.
Today's task: add a notifications panel that pulls from
the `notifications` table in Supabase.Common Beginner Mistakes
Over-relying on follow-ups. If you find yourself sending five correction messages after every response, the root cause is usually an underspecified first prompt. Slow down and front-load the detail.
Accepting the first output without reading it. Claude Code produces confident-looking code that may have subtle issues. Read the output before running it, especially for anything touching auth, payments, or data deletion.
Prompting for process instead of outcomes. “Write a function that loops through the array” describes how. “Return a deduplicated list of user IDs sorted by last login” describes what. The second prompt gives Claude room to choose the right implementation.
Asking for too much in one shot. See above — scope it tightly, verify the output, then continue.
Not using CLAUDE.md when it would help. If you have project-wide constraints that apply every session — currency format, a folder structure, a package you never want added — put them in a CLAUDE.md file at your project root. Claude Code reads it at the start of every session so you don’t have to repeat yourself.
A Practical Prompt Template to Start From
Here’s a structure you can copy and fill in for most Claude Code tasks:
Context: [tech stack, project type, relevant files]
Task: [what you want built or changed]
Constraints: [what to avoid, existing patterns to follow]
Output: [what the response should look like]In practice:
Context: Next.js 15 App Router, TypeScript, Tailwind CSS.
The form components live in /components/forms/.
Task: Build a newsletter signup form.
Email field only. POST to /api/newsletter on submit.
Constraints: No new packages. Match the existing Input and Button
components in /components/forms/.
Handle loading and error states inline.
Output: Just the component file — no explanation needed.This isn’t a rigid template. Drop sections that aren’t relevant. Add ones that are. The point is to build the habit of thinking through each element before you hit enter.
The Bigger Picture
Prompt engineering is a skill that compounds. Every task you complete teaches you something about how Claude interprets instructions — what it assumes when you’re vague, where it defaults to convention rather than your specific setup, which constraint types actually change the output.
The engineers who get the most out of Claude Code aren’t the ones with the cleverest prompts. They’re the ones who’ve built good instincts for what to specify and what to leave open. That comes from practice and from paying attention when the output isn’t what you expected.
If you want your team to build these instincts faster, I run hands-on AI training workshops for design and product teams. Get in touch to talk through what that could look like for your organisation.