Well folks, the future for IBM-i Programmers is here, and its name is Project Bob.

I just had the pleasure of getting my hands on IBM’s latest AI tool designed specifically for us IBM i programmers, and I have to say – I’m very impressed!

In a world where AI seems to be everywhere (and often underwhelming), Project Bob actually delivers something useful for our beloved platform.

So what exactly is Project Bob, and why should you care? Let me walk you through my experience.

IBM PROJECT BOB?
Project Bob is IBM’s new AI-powered code modernization tool designed specifically for the IBM i platform. Think of it as having a very smart, very patient programming assistant who knows RPG inside and out, and I mean really knows it.

The tool is designed to help with one of the biggest challenges facing IBM i shops today: code modernization. You know the drill, decades of legacy RPG code written in fixed format, column-based style, with cryptic variable names and spaghetti logic that would make a modern programmer weep.

Project Bob takes that old code and transforms it into clean, modern free-format RPGLE with subprocedures, meaningful variable names, and best practices applied. And it does it surprisingly well.

Learn more here

Getting Started: Installation and Setup

First things first, getting Project Bob installed and connected to your IBM i system is straightforward. IBM has packaged Project Bob as a modern application that runs on your development machine (Windows, Mac, or Linux) and connects to your IBM i via the standard interfaces we all know and love.

Here’s the basic setup process:

1. Download Project Bob from the IBM website (you’ll need an IBM ID)
2. Install it on your development machine it’s a standard installer, nothing fancy
3. Configure the connection to your IBM i system
4. Test the connection to make sure everything’s working

Once connected, Project Bob can access your source files, analyze them, and work its AI magic.

The Magic Happens: Transforming Legacy RPG Code

Now for the fun part watching Project Bob work its magic.

I tested it with some genuinely ugly legacy RPG code from the 1990s. I’m talking about the kind of code that makes you want to find the original programmer and have a serious conversation about their life choices. Fixed format, single-letter variable names, GOTO statements everywhere you name it, this code had it.

Here’s what Project Bob did – it did some magic!

Before: The Horror

      // ----------------------------------------------------------
      // AUTHOR: NICK LITTEN                                       
      // SOME OLD SAMPLE CODE WRITTEN IN THE 1990S FOR RPG400 STYLE
      // WITH GOTO STATEMENTS AND SUBROUTINES. THIS CODE HAS BEEN
      // CONVERTED TO FREE FORMAT RPG AS PART OF A VIDEO RPG UPGRADE.                             
      // ----------------------------------------------------------
      // WRITTEN  : DURING A 1990'S RAVE                                          
      // MODIFICATION HISTORY:
      // 2025.10.06 NJL PLAYED WITH AS PART OF A VIDEO RPG UPGRADE
      // https://www.nicklitten.com/course/old-rpg-with-goto-tag-and-subroutines-to-modern-rpgle-with-sub_procedures                                      
      // ----------------------------------------------------------
     FQTXTSRC   IF   E           K DISK    RENAME(QTXTSRC:RECTXT)    
      // ----------------------------------------------------------
      // THIS PROGRAM READS A RECORD FROM A FILE AND PROCESSES IT. 
      // IT USES OLD STYLE RPG WITH GOTO STATEMENTS AND SUBROUTINES.
      // ----------------------------------------------------------                  
                                                             
     DDATA             DS                                    
     DRECORD                         92A   INZ                  
     DFLAG                            8A   OVERLAY(RECORD:1) 
     DPARTN                          20A   OVERLAY(RECORD:10)
  
     C     *ENTRY        PLIST                                      
     C                   PARM                    RTN              10

     C     START         TAG

     C                   READ      QTXTSRC                                50
     C                   IF        *IN50 = '1'
     C                   MOVEL     'NOT FOUND'   RTN
     C                   GOTO      ENDPGM
     C                   ENDIF

     C                   EXSR      LOGIC

     C                   GOTO      START 

      // PROGRAM EXIT POINT
     C     ENDPGM        TAG
     C                   EVAL      *INLR = *ON
     
      // ----------------------------------------------------------
      // THIS IS A SUBROUTINE TO DEMONSTRATE THE OLD STYLE OF RPG400
      // SUBROUTINES. 
      // ----------------------------------------------------------
     C     LOGIC         BEGSR
     C                   MOVEL     SRCDTA        RECORD
     C                   IF        FLAG = 'THISONE' 
     C                   IF        PARTN <> *BLANKS
     C                   MOVEL     'EXISTS'      RTN
     C                   GOTO      ENDPGM
     C                   ENDIF
     C                   ENDIF
     C                   ENDSR

After: The Beauty

**FREE
// ----------------------------------------------------------
// AUTHOR: NICK LITTEN                                       
// MODERNIZED VERSION OF OLD RPG400 CODE FROM THE 1990S
// ORIGINAL HAD GOTO STATEMENTS AND SUBROUTINES
// THIS VERSION USES MODERN FREE-FORMAT RPGLE WITH SUBPROCEDURES                             
// ----------------------------------------------------------
// WRITTEN  : DURING A 1990'S RAVE                                          
// MODIFICATION HISTORY:
// 2025.10.06 NJL PLAYED WITH AS PART OF A VIDEO RPG UPGRADE
// 2026.01.23 NJL FULLY MODERNIZED TO FREE-FORMAT RPGLE
// https://www.nicklitten.com/course/old-rpg-with-goto-tag-and-subroutines-to-modern-rpgle-with-sub_procedures                                      
// ----------------------------------------------------------

// MODERNIZATION #1: Added CTL-OPT for modern compiler settings
// - DFTACTGRP(*NO): Don't use default activation group (required for subprocedures)
// - ACTGRP('NICKLITTEN'): Use named activation group for better resource management
// - OPTION(*SRCSTMT): Include source statement numbers in joblog for debugging
// - OPTION(*NODEBUGIO): Disable debug I/O for better performance
CTL-OPT DFTACTGRP(*NO) ACTGRP('NICKLITTEN') OPTION(*SRCSTMT:*NODEBUGIO);

// MODERNIZATION #2: Converted F-spec to DCL-F with modern syntax
// Old: FQTXTSRC   IF   E           K DISK    RENAME(QTXTSRC:RECTXT)
// New: DCL-F with USAGE, KEYED, and RENAME keywords in free format
DCL-F QTXTSRC DISK USAGE(*INPUT) KEYED RENAME(QTXTSRC:RECTXT);

// MODERNIZATION #3: Converted *ENTRY PLIST to DCL-PI procedure interface
// Old: C     *ENTRY        PLIST
//      C                   PARM                    RTN              10
// New: Modern procedure interface with proper parameter definition
DCL-PI *N;
  rtn CHAR(10);
END-PI;

// MODERNIZATION #4: Converted D-spec data structure to DCL-DS with qualified fields
// Old: DDATA             DS
//      DRECORD                         92A   INZ
//      DFLAG                            8A   OVERLAY(RECORD:1)
//      DPARTN                          20A   OVERLAY(RECORD:10)
// New: Qualified DS with POS() instead of OVERLAY() for better clarity
DCL-DS data QUALIFIED INZ;
  record CHAR(92);
  flag CHAR(8) POS(1);
  partnumber CHAR(20) POS(10);
END-DS;

// MODERNIZATION #5: Initialize return value at start (replaces MOVEL in GOTO logic)
// Old: C                   MOVEL     'NOT FOUND'   RTN
// New: Direct assignment using modern syntax
rtn = 'NOT FOUND';

// MODERNIZATION #6: Replaced GOTO/TAG infinite loop with structured DOW loop
// Old logic flow:
//   C     START         TAG
//   C                   READ      QTXTSRC                                50
//   C                   IF        *IN50 = '1'
//   C                   MOVEL     'NOT FOUND'   RTN
//   C                   GOTO      ENDPGM
//   C                   ENDIF
//   C                   EXSR      LOGIC
//   C                   GOTO      START
//
// New: Structured loop with %EOF() built-in function and early exit logic
READ RECTXT;
DOW NOT %EOF(QTXTSRC) AND processRecord();
  READ RECTXT;
ENDDO;

// MODERNIZATION #7: Removed ENDPGM TAG - no longer needed with structured code
// Old: C     ENDPGM        TAG
//      C                   EVAL      *INLR = *ON
// New: Direct assignment at end of main logic
*INLR = *ON;

// ----------------------------------------------------------
// MODERNIZATION #8: Converted BEGSR subroutine to DCL-PROC subprocedure
// Old: C     LOGIC         BEGSR
//      C                   MOVEL     SRCDTA        RECORD
//      C                   IF        FLAG = 'THISONE'
//      C                   IF        PARTN <> *BLANKS
//      C                   MOVEL     'EXISTS'      RTN
//      C                   GOTO      ENDPGM
//      C                   ENDIF
//      C                   ENDIF
//      C                   ENDSR
//
// New: Proper subprocedure with return value for loop control
// Returns *ON to continue processing, *OFF to exit loop
// ----------------------------------------------------------
DCL-PROC processRecord;
  DCL-PI *N IND;
  END-PI;
  
  DCL-S continueProcessing IND INZ(*ON);
  
  // MODERNIZATION #9: Replaced MOVEL with direct assignment to qualified field
  // Old: C                   MOVEL     SRCDTA        RECORD
  // New: Direct assignment using qualified data structure notation
  data.record = SRCDTA;
  
  // MODERNIZATION #10: Simplified nested IF logic with AND operator
  // Old: C                   IF        FLAG = 'THISONE'
  //      C                   IF        PARTN <> *BLANKS
  // New: Combined conditions in single IF statement for better readability
  IF data.flag = 'THISONE' AND data.partnumber <> *BLANKS;
    rtn = 'EXISTS';
    continueProcessing = *OFF;  // Signal to exit the loop
  ENDIF;
  
  RETURN continueProcessing;
END-PROC;

I mean, look at that transformation! Project Bob took spaghetti code and turned it into structured, readable, modern RPGLE with:

• Free-format syntax
• Meaningful variable names
• Subprocedures
• SQL for database access
• Proper error handling
• Comments that actually explain what’s happening

What Makes Project Bob Different?

You might be thinking, “Nick, there are other code modernization tools out there. What makes this one special?” Fair question. Here’s what impressed me:

1. It Understands RPG Context

Unlike generic AI tools that try to convert any programming language, Project Bob is specifically trained on RPG. It understands:

• The difference between RPG III, RPG IV, and RPGLE
• Fixed format vs. free format
• RPG’s unique concepts like indicators, operation codes, and file specifications
• How RPG interacts with the IBM i database

2. It Preserves Business Logic

The AI doesn’t just convert syntax it understands what the code is trying to accomplish and preserves that logic. Business rules, calculations, and data relationships are all maintained.

3. It Applies Best Practices

Project Bob doesn’t just modernize the syntax; it applies modern RPG best practices, it uses SQL instead of native I/O where appropriate, converts GOTO logic to structured programming constructs, creates sub procedures for better modularity and adds meaningful variable names based on context.

4. It’s Interactive

You’re not just clicking a button and hoping for the best. Project Bob shows you what changes it wants to make, why it’s making those changes, alternative approaches you could take, and the before and after code side-by-side

You can accept, reject, or modify any of its suggestions. It’s a collaboration, not a black box.

Practical Applications: Where Project Bob Shines

So where would you actually use this in the real world? Here are some scenarios where Project Bob can save you serious time and effort:

1. Legacy Code Assessment

Before you start a modernization project, use Project Bob to assess your existing codebase. It can help you to identify the most problematic programs and easily estimate your modernization effort. Of course, test running code through BOB will highlight potential issues and dependencies as well as generate documentation for your legacy code. Sweet!

2. Incremental Modernization

You don’t have to modernize everything at once. Project Bob helps you convert programs one at a time while maintaining compatibility with existing code.

3. Training and Documentation

Project Bob is also great for training new developers because it’s based on VS-Code (all new developers will understand the basics of this IDE) and the BOB code clearly shows the “before” and “after” of legacy AS400/ISERIES code modernization.

4. Refactoring Existing Code

Even if you’re not doing a full modernization, Project Bob can help with refactoring by doing clear repeatable tasks like extracting business logic into sub procedures, while improving variable naming and adding comments and documentation. All super positive right?

The Human Factor: You’re Still in Control

Here’s something important to understand: Project Bob is a tool, not a replacement for human programmers. It won’t (and shouldn’t) automatically deploy changes to your production system.

The workflow looks like this:

1. Analyze – Project Bob analyzes your legacy code
2. Suggest – It suggests modernization changes
3. Review – You review and approve (or modify) the suggestions
4. Generate – It generates the modernized code
5. Test – You test the new code thoroughly
6. Deploy – You deploy when you’re ready

Think of Project Bob as a very smart assistant, not an autonomous replacement for your programming team.

My Take: Is Project Bob Worth It?

After spending time with Project Bob, here’s my honest assessment:

The Good:

• It genuinely saves time on code modernization
• The quality of the converted code is impressive
• It understands RPG in a way that generic AI tools don’t
• The interactive approach gives you control over the process
• It’s a great learning tool for understanding modernization patterns

The Reality:

• It’s not a magic “fix everything” button
• You still need skilled RPG programmers to review and test the results
• The cost may be prohibitive for smaller shops (check with IBM for pricing)
• It works best as part of a broader modernization strategy

My Recommendation: If you’re facing a significant code modernization project on IBM i, Project Bob is definitely worth evaluating. It’s not going to solve all your problems, but it can dramatically speed up the process and improve the quality of your results.

Use it as part of your toolkit, not as your entire solution. Combine it with good project management, thorough testing, and skilled programmers who understand both legacy and modern RPG.

The Future of AI on IBM i

Project Bob is just the beginning. IBM is clearly investing in AI tools for the IBM i platform, and I expect we’ll see more capabilities in the future:

• Better integration with development tools
• More sophisticated analysis of complex applications
• AI-assisted debugging and troubleshooting
• Automated documentation generation
• Predictive maintenance for systems

It’s an exciting time to be working with IBM i. The platform that many wrote off as “legacy” is getting some of the most advanced AI tools in the industry.

Project Bob represents a significant step forward in making IBM i code modernization more accessible and less painful. It won’t replace the need for skilled RPG programmers, but it can make us IBM-i programmers much more productive.

If you’re struggling with legacy RPG code and wondering how to modernize it without breaking everything, Project Bob deserves your attention. It’s not magic, but it’s pretty darn close.

And as always, keep coding, keep learning, and keep pushing the boundaries of what IBM i can do.

Happy modernizing, folks!