Mastering Prompt Engineering for Developers: 6 Essential Prompting Techniques (Part 2)

In Part 1 of this series, we covered the 6 foundational techniques of prompt engineering, like Zero-Shot and Chain-of-Thought. You learned how to give basic commands, provide examples, and get the AI to "show its work."

Now, you're ready to level up.

If Part 1 was about giving instructions, Part 2 is about directing the conversation. These advanced techniques will give you a new level of control, allowing you to shape the AI's personality, constrain its output, and even have it collaborate with you to solve complex problems.

Let's dive into the next 6 techniques, all with practical examples.

7. Role-Based Prompting: The "Act As a..." Command#

What is it? This is one of the most powerful and popular techniques. You instruct the AI to adopt a specific persona or role. This role (e.g., "Senior Java Developer," "Database Architect," "Code Reviewer") dramatically filters its knowledge and changes its entire response style.

Why It’s Important: It's the fastest way to get a specific perspective. An AI acting as a "Code Reviewer" will be far more critical and detailed about code quality than one acting as a "Java Tutor," which would be more encouraging and simplistic.

Real-World Java Example: You have a piece of code and you want a professional, critical review.

Prompt:

"Act as a Senior Java Developer specializing in performance and concurrency. Review the following Java method. Focus on:

1. Thread-safety issues.
2. Potential performance bottlenecks.
3. Adherence to Java best practices.

Here is the method:

public class Counter {
    private int count = 0;

    public void increment() {
        count++; 
    }

    public int getCount() {
        return count;
    }
}

Result (from the AI):

"As a Senior Java Developer, I've reviewed your Counter class. Here is my analysis:

This class is not thread-safe.

Thread-Safety Issue: The increment() method presents a classic race condition. If two threads call increment() at the same time, the count++ operation (which is not atomic) can result in a lost update. Both threads might read the same value of count, increment it, and write the same value back, leading to an incorrect final count.

Performance Bottleneck: For this simple case, there isn't a major performance bottleneck, but the solution for thread-safety could introduce one.

Best Practices:

• Visibility: The count variable is not declared volatile. This means changes made by one thread might not be visible to other threads.
• Atomicity: To fix the race condition, you should use an AtomicInteger like this, which is the standard, high-performance way to handle concurrent counters:

 import java.util.concurrent.atomic.AtomicInteger;
    
    public class Counter {
        private AtomicInteger count = new AtomicInteger(0);
    
        public void increment() {
            count.incrementAndGet(); 
        }
    
        public int getCount() {
            return count.get();
        }
    }

8. Instruction-Based Prompting: The "Follow These Rules" Command#

What is it? Also known as "constrained prompting," this is where you give the AI a set of explicit, numbered rules or constraints that it must follow.

Why It’s Important: This is your tool for precision. When "good enough" isn't good enough, you use instructions to force the AI to adhere to specific naming conventions, import specific libraries, avoid certain methods, or format its output in a precise way.

Real-World Java Example: You need a Java class that follows your team's strict coding standards.

Prompt:

"Write a Java class for a User entity with the following strict rules:

1. It must be a POJO (Plain Old Java Object).
2. It must be in the package com.example.model.
3. It must have three private fields: userId (long), username (String), email (String).
4. It must include a no-argument constructor.
5. It must include a constructor for all fields.
6. It must include standard getters and setters for all fields.
7. DO NOT include a toString(), equals(), or hashCode() method."

Result (from the AI):

Java

package com.example.model;

public class User {

    private long userId;
    private String username;
    private String email;

    public User() {
        // No-argument constructor
    }

    public User(long userId, String username, String email) {
        this.userId = userId;
        this.username = username;
        this.email = email;
    }

    // Getters and Setters
    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

9. Task-Based Prompting: The "Unit of Work" Command#

What is it? This technique involves clearly defining a single, well-scoped, and specific task for the AI to accomplish. It's about breaking a large project (like "build an app") into its smallest logical sub-tasks (like "write a method that validates an email").

Why It’s Important: It prevents the AI from guessing, over-engineering, or doing too much. It keeps the response focused and gives you a clean, usable "unit of work" that you can integrate into your larger project. It's the building-block approach to AI development.

Real-World Java Example: You don't need a whole class, just one specific, testable piece of logic.

Prompt:

"Task: Write a single, static Java method named 'isValidPassword'. This method must:

1. Accept one String argument.
2. Return a boolean.
3. The password is valid if and only if it is at least 8 characters long AND contains at least one number."

Result (from the AI):

Java

public class PasswordValidator {

    public static boolean isValidPassword(String password) {
        if (password == null || password.length() < 8) {
            return false;
        }

        boolean hasNumber = false;
        for (char c : password.toCharArray()) {
            if (Character.isDigit(c)) {
                hasNumber = true;
                break;
            }
        }

        return hasNumber;
    }
}

10. Declarative Prompting: The "What, Not How" Command#

What is it? This is the opposite of instruction-based prompting. Instead of telling the AI the steps to take, you describe the end state or final result you want to achieve. You declare "what" you want, not "how" to do it.

Why It’S Important: This gives the AI creative freedom to find the most efficient or modern solution. You might be thinking of a clunky for loop, but the AI might know a cleaner, one-line Stream API solution. Use this when you care more about the result than the implementation.

Real-World Java Example: You need to perform a common data transformation.

Prompt:

"I have a List<Product> in Java. Each Product object has a getCategory() method. I need a Map<String, List<Product>> where each key is a category name and each value is the list of all products in that category."

Result (from the AI):(The AI will almost certainly choose the optimal "how")

Java

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class ProductService {

    public Map<String, List<Product>> groupProductsByCategory(List<Product> products) {
        return products.stream()
                .collect(Collectors.groupingBy(Product::getCategory));
    }
}

// Assuming a Product class like this:
// public class Product {
//     private String name;
//     private String category;
//     //...
//     public String getCategory() {
//         return category;
//     }
// }

11. Feedback Loop Prompting: The "Refine This" Command#

What is it? This is less a single prompt and more an interactive process. You get an initial response from the AI, provide corrective feedback, and ask it to regenerate or modify its answer. You repeat this loop until the result is perfect.

Why It’s Important: It's the most natural way to "collaborate" with an AI. For any complex task (like writing a new algorithm or a difficult service class), the first draft is rarely perfect. This technique lets you iteratively "sculpt" the final answer.

Real-World Java Example: You're building a function and refining it step-by-step.

Prompt 1:"Write a Java method that reads the contents of a file at a given path and returns it as a String."

Result 1 (from AI):

Java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderUtil {
    public String readFile(String filePath) throws IOException {
        StringBuilder content = new StringBuilder();
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        String line;
        while ((line = reader.readLine()) != null) {
            content.append(line).append(System.lineSeparator());
        }
        reader.close();
        return content.toString();
    }
}

Prompt 2 (Your Feedback):"This is good, but it's not using modern Java. Can you rewrite it using try-with-resources and Files.readString()?"

Result 2 (from AI):

Java

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class FileReaderUtil {
    public String readFile(String filePath) throws IOException {
        // This is much cleaner and ensures the file is closed.
        return Files.readString(Paths.get(filePath));
    }
}

12. Interactive Prompting: The "Ask Me Questions" Command#

What is it? This technique flips the script. Instead of you giving all the information, you explicitly ask the AI to ask you clarifying questions before it starts working.

Why It’s Important: Use this for large, ambiguous, or poorly defined tasks where you might not even know all the requirements. It forces the AI to become a requirements-gatherer, helping you think through the problem and ensuring the final result is what you actually need.

Real-World Java Example: You need to design a new component but haven't thought through all the details.

Prompt:

"I need to build a 'CacheService' class in Java for my Spring Boot application. It needs to cache product information.

``Before you write any code, ask me 3 questions to help you better understand the requirements."

Result (from the AI):

"Great, this is a common task. To design the best solution, I need a bit more information:

1. Cache Eviction Policy: What should the cache eviction strategy be? For example, should items expire after a certain time (Time-to-Live), or should the cache be limited by size (e.g., Least Recently Used)?
2. Cache Implementation: Are you planning to use a simple in-memory cache (like ConcurrentHashMap) or a distributed cache (like Redis or Ehcache)?
3. Data Consistency: How critical is it that the cached product information is always up-to-date? Is it acceptable for data to be slightly stale, or do you need a mechanism to manually invalidate the cache when a product is updated in the database? "

Where Do You Go From Here?#

You've now learned 12 powerful prompt engineering techniques. You've graduated from simply asking an AI for answers to architecting a conversation.

By combining these techniques—like using Role-Based Prompting with Feedback Loops, or Declarative Prompting within a Task-Based command—you can achieve a level of precision and quality that's impossible with simple, one-off questions.

The real mastery comes from practice. Go try to build a small Java project using only the AI, but direct it with these 12 techniques. You'll be amazed at the results.