☕ The RPG Developer’s Guide to Navigating Fear of Change

 Today’s Coffee: Starbucks Holiday blend — warm, smooth, familiar.

A reminder that even the smallest adjustments in flavor can create something entirely new without losing what made it comforting in the first place.

There’s a truth every seasoned IBM i developer understands but rarely says out loud:

We built systems that lasted.
And now the world is asking us to rebuild them while still running them.

That tension—the need to modernize while maintaining stability—is at the center of every fear you see on an RPG team today. Developers aren’t afraid of tools. They’re afraid of losing their footing in a world that’s shifting fast.

This is the most honest article I’ve written about the human side of modernization.
Because if you don’t deal with the fear, the tools don’t matter.

Why RPG Developers Fear Change (And Why It’s Rational)

Let’s be clear:

RPG developers run some of the most critical systems in the world.
Billing. Inventory. Healthcare. ERP. Distribution. Manufacturing.

The pressure isn’t theoretical.
It’s daily. It’s real. And it’s unforgiving.

So when a developer says:

• “I’m not comfortable with VS Code yet.”
• “Git scares me.”
• “I don’t want to break production.”
• “I can fix anything in SEU, but I’m slower in modern tools.”
• “SQL is powerful, but I don’t trust it yet.”
• “AI is cool, but not in my critical code path.”

…it isn’t resistance.

It’s responsibility.

IBM i developers aren’t fearful.
They’re protective—of the data, the workflow, the business, the customers.

This mindset is why IBM i systems have survived for decades with unmatched uptime.

Our job isn’t to erase that mindset.
Our job is to channel it into the next generation of tools and practices.

The Hidden Fears No One Talks About

Fear isn’t always loud. Sometimes it shows up in subtle ways:

Fear of losing expertise

If I’m not the fastest debugger in SEU anymore, who am I?

Fear of losing efficiency

If VS Code feels slower at first, won’t my productivity drop?

Fear of exposing knowledge gaps

What if someone realizes I don’t know SQL as well as I know native I/O?

Fear of new expectations

If I learn modern tools, will I be expected to do twice as much?

Fear of breaking “legendary” systems

Legacy = outdated
Legendary = proven, battle-tested, trusted
Developers fear destabilizing systems that have never failed them.

And, quietly:

Fear of being left behind

AI
VS Code
Git
CI/CD
APIs
SQL procedures
Open-source tooling
Project Bob
Cloud integration

It’s a lot—and it’s fast.

If you don’t acknowledge these fears, they become resistance.
If you do acknowledge them, they become growth.

What Modern IBM i Development Actually Requires

This section matters more than any tool list.
Because modernization isn’t about replacement.
It’s about evolution.

1. The ability to separate logic from the interface

RPG service programs. SQL views. APIs.
Your business logic should outlive the UI.

2. Comfort with databases as the center of architecture

DB2 for i is a strength—not an afterthought.
Modern RPG builds around SQL, referential integrity, and constraints.

3. Understanding that tools aren’t optional anymore

VS Code is the new standard.
Project Bob will reshape workflows.
Git isn’t “extra”—it’s part of development.

4. Willingness to learn in public

Push. Review. Comment. Fix. Iterate.
This is the new normal.

5. Resilience in the face of change

Every modernization effort brings uncertainty.
But uncertainty doesn’t mean danger—it means opportunity.

Practical Steps to Reduce Fear and Build Confidence

Now we go deeper—real strategies that work in real IBM i shops.

1. Start With “Minimum Viable Modernization”

You don’t need a giant project.

Try:

• One file converted to SQL
• One program converted to free-form
• One service program created
• One API wrapper created
• One Git branch used
• One unit test added
• One display file modernized
• One VS Code edit made

You reduce fear by reducing the size of the unknown.

2. Convert Old Knowledge Into New Workflows

Leverage existing strengths:

• The SEU navigation skills translate to VS Code keyboard shortcuts.
• The understanding of business rules translates to building APIs.
• The DDS knowledge translates into designing dynamic screens or React front-ends.
• The CL mastery translates into CI/CD pipeline scripting.

You’re not replacing expertise—you’re redirecting it.

3. Teach Developers to Break Work Into Smaller Pieces

Monolithic code is overwhelming.
Monolithic modernization is paralyzing.

Show developers how to break a 40-year-old module into:

• A new service program
• A validation layer
• A tiny SQL view
• A refactored loop
• A single free-form block

Small wins unlock momentum.

4. Build Psychological Safety Into the Team Culture

If developers feel unsafe admitting what they don’t know, modernization dies instantly.

Create norms like:

• “It’s okay not to know Git yet.”
• “We learn tools together.”
• “Pairing is encouraged, not a crutch.”
• “Everyone was new once.”
• “Asking for help is an expectation.”

This is what modern teams look like.

5. Use Project Bob and AI as Confidence Tools, Not Threats

The magic of Project Bob is simple:

It lowers the fear of getting lost.

AI can:

• explain code
• summarize modules
• show data flows
• propose refactors
• enforce coding standards
• generate documentation
• reduce onboarding time
• break down complex tasks
• generate test cases

And, importantly:

AI cannot replace decades of business logic that live in your head.

AI increases confidence.
Confidence reduces fear.
Reduced fear accelerates modernization.

What Leaders Must Do to Support the Evolution

Modernization fails when leadership treats it as:

• a technical upgrade
• a tooling project
• a rewrite initiative
• a deadline-driven mandate
• a cost-cutting exercise

Modernization succeeds when leadership treats it as skill evolution.

Here’s how:

1. Protect learning time

If developers can’t learn at work, they won’t modernize at all.

2. Set realistic expectations

Modernization requires new skills and new workflows.
This takes time.

3. Pair veterans with juniors intentionally

Veterans teach business rules.
Juniors teach new patterns.
Both grow.

4. Celebrate effort, not just output

The journey matters more than the speed.

5. Make the “why” bigger than the “how”

When developers understand the purpose, fear evaporates.

Final Sips

Today’s Starbucks Holiday Blend is familiar—but with a twist.
It mirrors what modernization asks of us:

Keep the comfort.
Add something new.
Blend tradition with evolution.

IBM i is entering its next chapter—VS Code, Project Bob, SQL-centric design, APIs, unit testing, CI/CD, continuous modernization.

Fear doesn’t mean you’re behind.
Fear means you care.

And caring is the first step toward mastering what comes next.

Modernization isn’t about abandoning what made you a great RPG developer.
It’s about unlocking what comes after.

☕ Follow The RPG Blend for more articles on RPG development, leadership, IBM i modernization, and the changing future of our platform.

 

Comments

Post a Comment