No history yet

AI Assisted Class Design

Architectural Prompting

You already know how to write a basic Java class. Now, let's move beyond manual coding and learn to direct an AI to build more complex structures for you. The goal isn't to have the AI think for you, but to handle the tedious parts of coding, freeing you up to focus on the overall design.

This starts with architectural prompting. Instead of just asking for "a class to represent a user," you provide a detailed blueprint. A good architectural prompt includes three key elements:

  1. Role: Tell the AI what hat it should wear. Is it a senior Java developer? A database architect? This sets the context for the conventions and patterns it should use.
  2. Context: Describe the problem domain. What is the purpose of this code? Is it for a high-performance system, a simple data transfer object, or part of a larger application?
  3. Constraints: Define the rules. Specify the Java version, required fields, immutability, visibility rules, and any specific methods it must include.

Think of it like this: a vague request gets you a generic blueprint. A detailed architectural prompt gets you a custom-built house.

Let's apply this to a practical example. We'll design a system for smart home devices. We need a way to represent devices that hold data without being changed after creation.

Java Records for Immutable Data

Immutable objects are a cornerstone of robust software design. They are simpler to reason about and safer in concurrent environments. Before Java 14, creating an immutable class meant writing a lot of boilerplate: private final fields, a constructor to initialize them, and getter methods for each field. You also had to manually override equals(), hashCode(), and toString().

Java Records automate all of that. A record is a concise way to declare a class that is an immutable data carrier. All the necessary boilerplate is generated by the compiler.

Here’s an architectural prompt to generate a record for a smart light bulb:

Prompt:

Role: You are a senior Java developer specializing in modern, idiomatic code.

Context: I am building a smart home management system. I need an immutable data carrier class for a smart light bulb.

Constraints: Generate a Java 17 record named SmartLight with the following components: a String for the device ID, an int for brightness level (0-100), and a String for color temperature (e.g., "warm white").

The AI would then generate the following code. Notice how simple it is.

public record SmartLight(String deviceId, int brightness, String colorTemperature) {
    // The compiler automatically generates:
    // - A canonical constructor
    // - Public accessor methods for each field (e.g., deviceId())
    // - Implementations of equals(), hashCode(), and toString()
}

All that boilerplate is handled for you. Your role as the architect is to verify the output. Does it use a record as requested? Are the data types correct? Does it meet the immutability constraint? In this case, yes. The AI handled the repetitive work perfectly.

Nested Classes and Enums with Behavior

Sometimes, a class is so tightly coupled with another that it doesn't make sense for it to exist on its own. This is where nested classes come in. They help you group related logic and control visibility.

Let's expand our smart home system. We'll create a SmartThermostat class. This thermostat has different operating modes (Heating, Cooling, Fan Only, Off). An enum is perfect for representing a fixed set of constants like this. But what if each mode had its own specific behavior? We can add methods and fields directly to the enum.

We also need a way to represent a scheduled event for the thermostat. A schedule is only meaningful in the context of a thermostat, making it a great candidate for a static nested class.

Prompt:

Role: You are a senior Java developer building a smart home API.

Context: I am designing a class for a SmartThermostat. It needs to manage its current state and a list of scheduled temperature changes.

Constraints:

  1. Create a public class SmartThermostat.
  2. Inside it, define a public enum OperatingMode with values HEATING, COOLING, FAN_ONLY, and OFF. Each enum constant should have a String description (e.g., "Actively heating.") and a method getEnergyConsumption() that returns a different integer value for each mode.
  3. Create a public static nested class ScheduledChange. It should be a record with a java.time.LocalTime and a target temperature as a double.
  4. The SmartThermostat class should have private fields for its device ID (String), current temperature (double), and a List of ScheduledChange objects.
  5. Generate a constructor and appropriate accessor methods for the SmartThermostat.

Here's the kind of complete, structured code an AI would generate from that prompt.

import java.time.LocalTime;
import java.util.List;

public class SmartThermostat {

    public enum OperatingMode {
        HEATING("Actively heating.", 1500),
        COOLING("Actively cooling.", 2000),
        FAN_ONLY("Circulating air.", 300),
        OFF("Idle.", 5);

        private final String description;
        private final int energyConsumptionWatts;

        OperatingMode(String description, int watts) {
            this.description = description;
            this.energyConsumptionWatts = watts;
        }

        public String getDescription() {
            return description;
        }

        public int getEnergyConsumption() {
            return energyConsumptionWatts;
        }
    }

    public static record ScheduledChange(LocalTime time, double targetTemperature) {}

    private final String deviceId;
    private double currentTemperature;
    private OperatingMode mode;
    private final List<ScheduledChange> schedule;

    public SmartThermostat(String deviceId, double currentTemperature, List<ScheduledChange> schedule) {
        this.deviceId = deviceId;
        this.currentTemperature = currentTemperature;
        this.schedule = schedule;
        this.mode = OperatingMode.OFF;
    }

    // Accessors (getters and setters)
    public String getDeviceId() {
        return deviceId;
    }

    public double getCurrentTemperature() {
        return currentTemperature;
    }
    
    // ... other getters and setters
}

Now, you verify. The AI correctly created an enum with fields and methods, a static nested record, and the main class structure. Your architectural prompt guided it to produce exactly what you designed, saving you from writing dozens of lines of code.

Your job shifts from a typist to a reviewer. You check for logical flaws. For instance, should the list of scheduled changes be mutable? Maybe it should be an unmodifiable list to prevent accidental changes. This is where your human oversight provides value, refining the AI's output to be more robust.

Quiz Questions 1/6

What are the three key elements of a good architectural prompt for guiding an AI, as described in the text?

Quiz Questions 2/6

Which Java feature is best suited for creating a simple, immutable data carrier class while minimizing boilerplate code?

By mastering architectural prompting, you can leverage AI to accelerate development while you focus on the high-level design, logic, and correctness that truly matter.