Prompt Engineering for Developers: The Patterns That 10x Your AI Coding Output

The difference between a developer who gets mediocre AI coding output and one who gets excellent output is almost entirely in how they prompt. Not model selection. Not tool choice. Prompting. Specifically: whether they specify constraints, provide examples, use structured thinking, and define what “done” means. These patterns apply equally to Cursor, Claude Code, and direct API calls.

⚡ TL;DR: Five patterns that multiply AI coding quality: (1) Few-shot examples for code style, (2) Chain-of-thought for debugging, (3) Constraint specification to prevent scope creep, (4) Role prompting for architecture decisions, (5) Negative prompting to prevent specific bad patterns. Use all five on any non-trivial task.

Pattern 1: Few-shot examples for code style

# WITHOUT few-shot: AI uses its "default" style — often not yours
Prompt: "Write an Express route handler for updating a user"

# RESULT: Generic Express handler with try/catch, res.json(), etc.
# NOT your team's patterns

# WITH few-shot: AI learns your exact patterns from examples
Prompt: "Write a route handler for updating a user. Follow the EXACT style of these examples:

Example 1:
// PUT /users/:id/profile
router.put('/users/:id/profile', authenticate, async (req, res, next) => {
  const result = await userService.updateProfile(req.params.id, req.body);
  if (result.isErr()) return next(result.error);
  res.json({ data: result.value });
});

Example 2:
// PUT /orders/:id/status
router.put('/orders/:id/status', authenticate, authorize('admin'), async (req, res, next) => {
  const result = await orderService.updateStatus(req.params.id, req.body.status);
  if (result.isErr()) return next(result.error);
  res.json({ data: result.value });
});

Now write the handler for PUT /users/:id/password"

# RESULT: Exactly matches your Result type pattern, authentication middleware usage,
# error handling style, and response format

Pattern 2: Chain-of-thought for debugging

# WITHOUT chain-of-thought: AI jumps to first plausible solution
Prompt: "Fix this error: TypeError: Cannot read property 'id' of undefined"
# RESULT: Changes one line, doesn't understand the root cause

# WITH chain-of-thought: forces systematic diagnosis
Prompt: "Debug this error. Think step by step:

1. First, identify ALL places where 'user' could be undefined in this code
2. For each place, explain WHY it might be undefined (not just where)
3. Identify which one is causing this specific error based on the stack trace
4. Only then suggest the fix
5. Explain how to prevent this class of error in the future

Error:
[stack trace]

Code:
[paste the relevant code]"

# RESULT: Systematic analysis that finds the ACTUAL root cause
# instead of patching the symptom

Pattern 3: Constraint specification

# WRONG: goal without constraints
"Add caching to the user service"
# RESULT: AI introduces Redis, adds 3 new dependencies, ignores existing patterns

# RIGHT: goal + explicit constraints
"Add caching to the getUser method in UserService. Constraints:
- Use ONLY the existing Redis client at /lib/redis.ts (already configured)
- Cache TTL: 5 minutes (match the session TTL in /config/auth.ts)
- Cache key pattern: user:{id} (consistent with existing keys — see /lib/cache-keys.ts)
- Do NOT add new dependencies
- Do NOT cache the entire User object — cache only the public UserDTO
- If Redis is unavailable, fall through to database (no errors)
- Add a test that verifies the cache is hit on second call"

# The constraint list:
# 1. Prevents new dependencies (most common AI scope creep)
# 2. Forces use of existing patterns
# 3. Defines the exact behavior of edge cases
# 4. Requires a test (forces interface-first thinking)

Pattern 4: Role prompting for architecture

# Role prompting shifts the perspective and produces different answers

# As a junior developer (default AI mode):
"How should I add real-time notifications to this API?"
# RESULT: Suggests WebSockets, socket.io, whatever is most popular

# As a senior architect:
"You are a senior backend architect who has maintained large Node.js systems
for 10 years. When recommending solutions you always consider:
- Operational complexity (fewer moving parts = better)
- Failure modes and what happens when the new component goes down
- Whether existing infrastructure can solve this without new services
- Incremental adoption (can we start simple and scale later?)

Given our current stack (Node.js, PostgreSQL, Redis, deployed on Fargate),
how should I add real-time notifications to this API?
Consider: SSE vs WebSockets vs polling vs push notifications.
For each option, explain the failure mode."

# RESULT: Nuanced trade-off analysis, not just the popular choice

Pattern 5: Negative prompting

# Explicitly list what NOT to do — prevents AI's most common mistakes

"Refactor the OrderService class to use the repository pattern.

Do NOT:
- Add any new dependencies (no new npm packages)
- Change the public interface — all method signatures must stay identical
- Use abstract classes or complex inheritance hierarchies
- Add decorator patterns or metadata
- Change any existing tests

DO:
- Create a new OrderRepository class at /src/repositories/order.repository.ts
- Move all database calls from OrderService to OrderRepository
- Inject the repository via constructor (see UserService for the pattern)"

# The "Do NOT" list is equally important as the "DO" list
# AI commonly adds complexity without being asked — negative prompting prevents this

• ✅ Few-shot: show 2 examples of the exact style before asking for code
• ✅ Chain-of-thought: tell the AI to reason step by step before suggesting a fix
• ✅ Constraints: explicit list of “do not” is as important as the goal
• ✅ Role prompting: specify seniority and values for architecture decisions
• ✅ Negative prompting: prevents the most common AI scope creep patterns
• ❌ Do not describe the goal without defining what “done” looks like
• ❌ Do not skip examples — AI defaults to the most common pattern, not your pattern

These prompt patterns work across all tools — apply them in Claude Code, Cursor’s Composer, and direct API calls. For building automated code generation pipelines, the structured output guide shows how to encode these patterns into production generation pipelines. External reference: Anthropic prompt engineering guide.