How GenAI Can Replace Coding: A Real Case Study in Java

The buzz around Generative AI (GenAI) and its potential to replace various aspects of the software industry is undeniable. Yet, finding concrete case studies to support this claim often takes significant time. To address this gap, I’ve decided to present my introductory case study—a practical "how-to" example. While this article focuses on introducing the concept, the detailed workings of code generation with GenAI will follow in subsequent articles.

This case study demonstrates how GenAI can generate Java (Spring Boot) code. The training process was conducted using the OpenAI platform.

Key Terminologies and Definitions

To effectively train OpenAI for code generation, three critical elements are required:

1. API Structure Visualization: A clear representation of the API (endpoint) details.
2. JSON Structures: Both input and output representations.
3. Project File Structure: A sample file layout of the project.

The 5 Sources of Backend Programming

To begin coding or training a GenAI model, we must first identify five key sources. These apply universally across different types of software projects, whether they involve gaming, ERP, socket programming, web development, or more:

1. API Name: This could be a function name, procedure name, or microservice name.
2. Input Parameters: The data expected to be sent to the API.
3. Output Parameters: The data returned by the API.
4. Input Validations: Rules to ensure inputs are correct, along with overall validation logic.
5. Operation Descriptions: Clear, concise descriptions of what the endpoint is supposed to do.

These five sources form the foundation for training GenAI effectively.

API Cards: A New Approach to Visualization

Modern API documentation tools like Swagger, Postman, Redoc, and RAML are excellent for many purposes but fall short when it comes to training GenAI. To address this, we created a more structured and flexible tool called the API Card.

What is an API Card?

An API Card is a generalized representation of an API endpoint. It can describe endpoints, microservices, functions, or procedures. Its goal is to help anyone—product owners, business analysts, or product managers—document APIs without requiring coding expertise.

Sections of an API Card

The API Card consists of five sections:

1. Inputs: Lists input parameters with their descriptions.
2. Outputs: Lists output parameters with their descriptions.
3. Request Body: Provides a JSON or XML representation of the inputs.
4. Response Body: Provides a JSON or XML representation of the outputs.
5. Operations: Includes input validations, overall validations, and a one-sentence description of the endpoint’s functionality (strictly limited to one sentence).

Example Use Case

Imagine a product manager on a team developing an e-commerce platform. Using an API Card, they can document an endpoint for creating a new user. This ensures clarity for both technical and non-technical team members.

JSON Representation of the API Card

Since GenAI primarily accepts JSON for training, we convert the API Card into a JSON format. The structure of the JSON is flexible and customizable. Below is an example:

Training the OpenAI Platform

Once the JSON representation of the API Card is ready and the corresponding code is written by developers, training begins. Here’s how it works:

1. Upload the JSON API Card as the input.
2. Upload a ZIP file of the source code (e.g., from a Git repository) as the output.
3. Write automation scripts to manage training iterations.

Training often requires 40-50 iterations for the GenAI platform to fully understand the software architecture, file structure, and coding patterns.

Details of these steps I’ll share in upcoming articles.

Results: Generating Java Code with GenAI

After successful iterations, the GenAI platform can generate source code based solely on the JSON input. Below is an example of how the GenAI platform generates a Spring Boot endpoint:

The code generation process is fully automated in our system. It takes the response from OpenAI, integrates it into the project, and generates a functional endpoint. For the sake of demonstration, I manually triggered OpenAI and captured the output to display here.

?

Conclusion

As demonstrated, software architecture and the API Card play a crucial role in integrating GenAI effectively. In the next 2–3 years, GenAI systems will likely generate not only simple and standard code but also complex algorithmic solutions. This shift may significantly reduce job opportunities for junior and mid-level developers, as advanced programming and deep understanding of data structures become the primary demand.

Additionally, roles such as product owners, product managers, and agile coaches will need to broaden their skillsets. A strong foundation in fundamental coding and database principles will become essential to thrive in this evolving landscape.

This case study demonstrates how GenAI can streamline software development by generating boilerplate code based on structured input. Although this is just the beginning, the potential for GenAI to replace manual coding in routine tasks is clear. In upcoming articles, I’ll dive deeper into the mechanics of training OpenAI and explore more complex examples.

#AgileCommunicationFramework #AgileCommunication #DigitalProductManagmentInstitute #DPMInstitute

Follow me to explore a fresh perspective on Digital Product Management and learn how to become an Agile Communication Professional.