Guru: WCA4i And Granite – Because You’ve Got Bigger Things To Build

September 15, 2025 Gregory Simmons

They said AI would change everything. Then most of it turned into chatbot demos and marketing decks. But watsonX Code Assistant for i (WCA4i for short), backed by IBM’s own Granite large language model, is doing something IBM i developers might actually care about: Helping you understand, transform, and evolve legacy code without tossing decades of business logic into the fire.

WCA4i isn’t trying to slap a web UI over your green screens or auto-generate JavaScript for the sake of buzzwords. It’s aimed at something deeper – leveraging an AI foundation model that’s actually trained on IBM i code and workflows. Yes, including RPG – even fixed-format. Granite recognizes the structure, intent, and subtle rules of your code – especially the kind that’s been running quietly and reliably for decades.

This matters, because modernization on the IBM i isn’t about redesigning screens – it’s about decoding systems that have grown over time, usually with a mix of tribal knowledge, missing documentation, and that one program no one dares touch. WCA4i, using IBM’s Granite LLM, is going to be the tool that helps you navigate that complexity – without demanding a rewrite or a miracle.

At its core, Granite helps WCA4i understand what your programs are actually doing, not just what they look like. It analyzes business rules, maps workflows, and spots dependencies that even experienced developers might miss when staring down a few thousand lines of spaghetti logic. That makes WCA4i more than a code assistant – it’s a co-pilot with context, something IBM i shops haven’t really had until now.

Importantly, it doesn’t try to take over. This isn’t an “AI will replace developers” story. If anything, it’s the opposite. WCA4i is built to augment what experienced IBM i developers are already doing – streamlining repetitive tasks, highlighting modernization candidates, and offering suggestions that actually make sense given the codebase, not just the syntax.

In my testing, while WCA4i is quite impressive, it may not be quite ready for those tasks I am most excited for; code transformation and code completion prompting. Where WCA4i shines however, is in its Explain and Summarize functions. Given this small program:

**Free
Ctl-Opt Main(Get_Cur_Date);
Ctl-Opt Debug Option(*SrcStmt:*NoDebugIO);
Ctl-Opt ActGrp(*Caller);

Dcl-Proc Get_Cur_Date;

  Dcl-Pi Get_Cur_Date;
    CurDate Char(10);
  End-Pi;

  Exec SQL
    Set :CurDate = Current_Date;

  Return;

End-Proc Get_Cur_Date;

I edited this program in VS Code, with the WCA4i extension installed. My procedure is automatically decorated with these four clickable decorators: Explain | Summarize | Usage | Document.

My first exploratory click on Explain WCA4i returned a bullet pointed listing, as many AI platforms do. The text was quite lengthy; for a 17-line program, the response was 258 words over five bullet points, about a page and a half. I won’t bore you with the lengthy response, but the summation of the bullet pointed sections of response were:

Purpose: Just as I would expect, it provided a much longer response than necessary on the basic function of this program, which is simply to populate the variable CurDate with the current date.

Global Components: A small paragraph about input/output files (which this program has none) as well as local variables. In the above example’s case, just the one – CurDate.

Main Execution Flow: Perhaps some may argue that this section was too wordy, but the information was accurate. The procedure defines the one input/output parameter, CurDate. Then it executes an SQL statement to set the value of CurDate to the current system date and then the procedure returns control to the caller.

Possible Problems With This Code: This one I will quote verbatim: “The code appears straightforward and has no apparent issues. However, one potential problem could arise if the SQL statement fails; the error would not be handled explicitly, which might lead to unexpected behavior or crashes.” This is a very good reminder that as I have preached to my students and colleagues many times, you should always follow every SQL statement with some sort of check to see whether the SQL statement worked or not. Excellent!

Possible Improvements To This Code: Three more bullet points, AI loves the bullet points! A note suggesting I add some error handling after the SQL statement; great! Consider adding logging to record when and why the procedure was called. Could be helpful to aid in debugging/troubleshooting. And this last one was a little odd: Consider using a data structure to encapsulate date-related operations instead of passing a simple character variable… It went on more, talking about how I could expand this program.

As the developer who wrote this program, I found that the first three sections weren’t all that useful. But the last two sections, which I didn’t expect as part of an Explain response, I found surprisingly insightful.

The real value of the Explain function, I think, lies in helping developers who didn’t write the code. Imagine a team working on a 14-month project that suddenly gets reassigned to a different group. The new team has to sift through thousands – maybe millions – of lines of code to figure out the system’s functional areas. This function could be a huge help.

For developers already familiar with the program or adjacent code, the Summarize function is more my style. Here’s what WCA4i returned:

“This ILE RPG code defines a procedure Get_Cur_Date that retrieves the current date using SQL’s CURRENT_DATE function and stores it in a character variable CurDate.”

Short and sweet. In some cases, it could even serve as auto-generated documentation.

The ‘Usage’ function, while again more bullet points, did have some useful information about how to use the program. I especially liked this usage example:

Dcl-S Today Date;
CallP Get_Cur_Date(Today);
Dsply ('Today''s date is ' + Today);

The IBM team working on WCA4i hasn’t put out a pre-release version of the ‘Document’ function yet. But from what I’ve seen thus far from the Granite LLM’s ability to read and understand my code, I’m excited to see what the document function shows us. I should also mention that the WCA4i team has been releasing updates often. The pre-release version of WCA4i is changing, and will continue to change. Thus, some of my experiences I’ve shared may not match your experience when it is ready for general availability.

In a world full of AI hype, WCA4i is refreshingly grounded. It’s not here to disrupt the platform. It’s here to support the people who’ve kept it alive and thriving for decades. And with Granite under the hood, it might finally be the kind of smart tool IBM i developers have deserved for a long time.

Because let’s face it: you’ve got bigger things to build.

Until next time, happy coding.

Gregory Simmons is a Project Manager with PC Richard & Son. He started on the IBM i platform in 1994, graduated with a degree in Computer Information Systems in 1997 and has been working on the OS/400 and IBM i platform ever since. He has been a registered instructor with the IBM Academic Initiative since 2007, an IBM Champion and holds a COMMON Application Developer certification. When he’s not trying to figure out how to speed up legacy programs, he enjoys speaking at technical conferences, running, backpacking, hunting, and fishing.

This Issue Sponsored By

Table of Contents

Content archive

Recent Posts

Subscribe

Pages

Search