Prompt Engineering for Developers: Getting Better Results From AI Coding Tools

I have been using AI coding tools daily since early 2023. In that time, my prompting has gone from "write a function that does X" (mediocre results) to consistently getting production-quality code on the first try. The difference is not the model improving (though it has) — it is how I communicate with the model.

Here are the techniques that make the biggest difference in practice.

The Context Problem

AI models have a fundamental limitation: they only know what you tell them. When you ask "write a function to fetch user data," the model does not know: your tech stack, your coding conventions, your error handling patterns, whether you use TypeScript, what your User type looks like, or how your API is structured.

Without context, the model guesses. Sometimes it guesses right. Often it does not.

The single most impactful improvement to your prompting: provide context before asking for code. Tell the model what it needs to know to produce code that fits your codebase.

Technique 1: Specify the Stack and Conventions

Bad prompt: "Write a function to fetch blog posts"

Good prompt: "Write a TypeScript function that fetches published blog posts from our Prisma database. We use Next.js App Router server components. Our coding style: use async/await, handle errors with try-catch that returns null on failure, use type inference (no explicit return types unless necessary). The BlogPost model has: id, slug, title, excerpt, bodyMd, isPublished, publishedAt, authorId."

The good prompt produces code that works in your project without modification. The bad prompt produces generic code that needs 5 minutes of adaptation.

Technique 2: Provide Examples of Existing Code

The most powerful context: show the model how similar things are done in your codebase.

"Here is how we fetch tools in our codebase:

async function getTools(filter: ToolFilter) {

try {

const tools = await db.tool.findMany({

where: { isActive: true, ...filter },

include: { category: true },

orderBy: { rating: 'desc' },

});

return tools;

} catch {

return [];

}

}

Write a similar function to fetch AI products with their pricing tiers."

The model produces code that matches your patterns exactly — same error handling, same Prisma query style, same structure. Consistency without effort.

Technique 3: Specify What You Do NOT Want

Models tend toward verbosity and over-engineering. Telling them what to avoid produces cleaner code.

"Write a React component for a tool card. Do NOT: add comments to obvious code, add PropTypes or runtime type checking (TypeScript handles it), add error boundaries (handled at the layout level), add loading states (handled by Suspense), or add accessibility attributes beyond semantic HTML (we add those separately)."

Without negative constraints, you get a 100-line component with defensive coding for scenarios that your architecture already handles. With constraints, you get a focused 30-line component.

Technique 4: Think Step by Step for Complex Tasks

For non-trivial tasks, ask the model to plan before coding.

"I need to implement a search feature for our tool directory. Before writing code, outline: 1) What the search API endpoint should accept and return. 2) How we should query the database (full-text search strategy). 3) How results should be ranked. 4) What the React component should look like. Then implement it."

This forces the model to think through the architecture before diving into implementation. The result is more coherent, better-structured code because the model planned the overall approach first.

Technique 5: Iterative Refinement Over One-Shot

Do not try to get a perfect result in one prompt. Start simple and iterate:

Prompt 1: "Write a basic tool search endpoint that accepts a query parameter and returns matching tools from the database."

[Model produces basic implementation]

Prompt 2: "Now add relevance ranking. Exact name matches should rank highest, then category matches, then description matches."

[Model enhances the implementation]

Prompt 3: "Add pagination with cursor-based navigation and a total count."

[Model adds pagination]

Each step is small and verifiable. You catch problems early instead of debugging a complex one-shot implementation.

Technique 6: Ask for Alternatives

When you are not sure about the best approach:

"I need to implement rate limiting for our API. Show me two approaches: one using Redis for distributed rate limiting, and one using in-memory with a Map. For each, explain the trade-offs. Then recommend which is better for our use case (single Next.js server on Vercel with moderate traffic)."

This gives you options with trade-off analysis. Often the model's second suggestion is better than what you would have chosen independently.

Technique 7: Code Review Prompts

Use AI to review your own code:

"Review this function for: potential bugs, edge cases I might have missed, performance issues, and TypeScript type safety. Be specific — do not just say 'looks good.' Point out actual issues."

Then paste your function. The model is surprisingly good at finding: unhandled null cases, potential race conditions, inefficient algorithms, and TypeScript type narrowing issues.

Technique 8: Debugging With Full Context

When debugging, provide all relevant information:

"I am getting this error: [paste error]. It happens when [describe the scenario]. Here is the relevant code: [paste the function]. Here is the relevant type: [paste the type]. What is causing this and how do I fix it?"

The more context you provide, the more likely the model identifies the actual cause. Without context, it guesses — and debugging requires precision, not guessing.

What AI Coding Tools Are Bad At

Knowing when to stop: models tend to over-implement. They add error handling for impossible scenarios, create helper functions that are used once, and add features you did not ask for. Be explicit about scope.

Understanding your business logic: the model does not know that "admin" means something specific in your system, that certain operations are restricted to Pro users, or that your pricing has special edge cases. Always verify business logic in AI-generated code.

Performance optimization without measurement: models optimize based on general knowledge, not your specific data patterns. They might suggest an index that is perfect for their assumed data distribution but wrong for yours. Always validate with real data.

Security-critical code: while models know security patterns, they can also introduce subtle vulnerabilities (SSRF, timing attacks, insecure defaults). Always have a human review security-critical code.

The Meta-Skill

The meta-skill of prompt engineering is knowing what the model needs to produce good output. This means:

Understanding your own codebase well enough to describe its patterns.

Knowing what context is relevant and what is noise.

Recognizing when the model's output is wrong or subtly off.

Being able to iterate toward better results instead of giving up.

This meta-skill improves with practice. The more you use AI tools, the better you get at communicating with them. It is genuinely a learnable skill, not a fixed ability.

The Honest Assessment

AI coding tools make me about 30-40% more productive on implementation tasks (writing new code that follows known patterns). They make me maybe 10% more productive on architecture and design (where the value is in thinking, not typing). They make me 0% more productive on debugging novel issues (where context and reasoning matter more than code generation).

Use AI tools where they excel — implementation, boilerplate reduction, pattern application. Do not expect them to replace thinking, architecture, or the creative aspects of software development. The developers who use AI best treat it as a very fast, very knowledgeable junior developer who needs clear instructions and code review.