Adapting to Change in Software Development

Change is the hardest part of modernization—not the tooling, not the code. The mindset. This week, I wrote about something every IBM i team faces but rarely discusses openly: the fear of change inside RPG development groups. After 30+ years on the platform, I’ve seen every type of hesitation—fear of breaking something, fear of looking inexperienced, fear of losing relevance. But I’ve also seen teams transform when leaders understand how to guide developers through those fears, not push past them. In this article, I break down: • Why fear of change is normal (and even useful) • How leaders can create safety without lowering expectations • The difference between resistance and uncertainty • Practical steps to help RPG devs build confidence with new tools • What trust, training, and clarity really look like in a modernization effort • How to move a team forward without burning them out or leaving people behind This one blends leadership and technical perspective—because modernization requires both. If your team is working through the shift to Git, VS Code, SQL, or soon Project Bob, this will help you navigate the human side of that journey. I’d love to hear your own experiences mentoring IBM i developers through change. What worked? What didn’t? —George VanEaton The RPG Blend

Last night I had one of those rare “the ground is shifting beneath us” moments. I was working on a small side project—a family tree application I’m building to help our extended family stay connected. Instead of writing the updated code myself, I described what I wanted in comments and let an AI coding agent handle the implementation. What would have taken hours (or days) of design, coding, and debugging became an interactive dialogue: define intent, review output, refine, repeat - completed in minutes. It struck me that this is not just a productivity boost—it represents a fundamental change in how software is built. The traditional model of large development teams writing code line by line will give way to smaller groups led by strong architects who design systems and orchestrate software agents to execute. The core skill shifts from “writing code” to “defining outcomes, constraints, and trust boundaries.” This raises important questions for every enterprise: How do we govern systems that can evolve as quickly as we can describe them? What does the workforce look like when human developers are paired with autonomous builders? How do we recruit and develop talent for a world where judgment, architecture, and accountability matter more than syntax? As innovation accelerates, governance must keep pace. That’s exactly why we see the need for platforms like i-GENTIC AI —designed to embed oversight, compliance, and transparency directly into workflows rather than trying to bolt them on after the fact. We are entering a new era of software development. The organizations that succeed will be the ones that learn how to design, guide, and govern intelligent builders—not just manage human ones. Zahra Timsah PhD, MBA, MSc, Scott Van Valkenburgh, Jim Edwards

I've come to reconsider my perspective on the effects of Agentic development. Initially, I thought it was a conversation about tooling, but I now believe it has evolved into a fundamental reevaluation of job roles and process expectations in engineering. If we look back at other engineering transformations, this one reminds me more of the adoption of social, distributed version control (read GitHub) and cloud computing (read AWS). Social distributed version control provided an excellent example of how technology shifts can fundamentally alter process expectations. The leap from Subversion to Git isn't giant; sure, the tooling has become more complicated, but it has also become more powerful. The sea change came by reorienting around pull requests, feature branch development, and CI/CD. This provided us with tools and conventions for breaking down work, facilitated by agile methodologies, and enabled us to divide work and responsibilities among engineers effectively. The shift to cloud computing and the accompanying DevOps movement have revealed a significant change in job expectations. We observed substantial shifts in our approach from CapEx to OpEx for infrastructure investments, capacity planning, and infrastructure change management. Successful organizations drove infrastructure choices into their engineering organization, reduced deployment timelines, and improved performance and availability. They also took what used to be a job, racking and stacking machines, and reimagined hardware management as software under version control. It took a deep understanding of middleware configuration out of the hands of deep experts and turned it into a self-service API more accessible to developers. The AI transformation we're experiencing today shares the same fundamental characteristics as these previous shifts: it's not just about the tools, but about reimagining how we work. Just as Git transformed collaboration patterns and cloud computing redefined infrastructure ownership, AI is reshaping the very nature of engineering work itself. For engineering leaders, this means our focus must shift from simply rolling out AI tools to fundamentally rethinking our processes, skill development, and team structures. To be successful, you need to recognize AI adoption as a cultural and operational transformation, not merely a technical upgrade. Just as DevOps wasn't really about the tools but about breaking down silos and changing mindsets, successful AI adoption requires us to embrace new ways of thinking about software development itself. The journey we've started from change management through experimentation to process transformation is just the beginning. The real work lies in continuously evolving our practices as these tools mature and in preparing our teams for a future where the line between human and AI contribution becomes increasingly blurred, but human judgment, creativity, and leadership become more valuable than ever.

If I've learned nothing else from all of the systems I've migrated, installed, and implemented, it is this: It is never just about the platform or technology. It is about the change that those systems bring. Opportunities for new workflows, opportunities for new functionalities, and on the downside, sometimes lost functionality or more complex workflows. Not every system/platform is going to equally increase functionality and efficiency across all functional areas. Some work will much easier, some may be exactly the same, and other work may take more time OR even another technology to fill in the gap (a plugin, a module, a 3rd party software or platform, etc.) Part of prepping for new technology is not only clearly identifying needs (including any restrictions) and requirements to get the most appropriate technology, but also figuring out how the new software/platform will be used. How is the old system used? How will that work migrate to a new system? Don't just transfer data and workflows -- use the system change to recalibrate and build a new way forward, keeping what works, reducing or eliminating what doesn't, to the extent possible. Involve your staff and get everyone on board. Everyone who works in a system or with a system has valuable insights! Leverage collective knowledge to build the future. #systemmigrations #tips #changemanagement #bethechange #systemigration #libraries #archives #softwaremigration

The next few years are going to be tough. Many legacy applications finally need to be modernized.  10 actions to survive. 1. Focus: Not every functionality needs to be migrated. Strict scope management based on real customer needs is crucial. What's your approach to scope prioritization? 2. Outcome-driven: Delivered functionality isn't the main success criterion - improved business value is. In my last project, we delivered 18% more revenue with just 60% of the migrated functionality. What metrics matter most in your modernization efforts? 3. Data-driven: Validate the value of each delivered feature through A/B testing. Combine quantitative data with user stories to paint the complete picture. 4. Incremental and iterative: From month one, deploy continuously to production through a robust delivery pipeline. Daily releases should be your minimum target. Agile and DevOps work. 5. Fail fast: Build and validate technically risky and commercially important functionalities first. Minimize basic functionality. Effectiveness before efficiency. 6. Experience-based: Don't reinvent the wheel. Learn from others who've succeeded. Shamelessly adopt state-of-the-art practices that work. 7. Human-centric: Your employees are critical to success. They understand customer needs, business processes, and legacy systems. Blend their experience with external expertise and invest in change management. 8. Be adaptable: We plan, God laughs. Observe, reflect, and adapt regularly at every organizational level. Stay self-critical and embrace change. 9. Cost-aware: Modernization isn't just about technology - it's about business value. Track and communicate both investment and returns. Create transparency about technical debt reduction and new revenue opportunities. 10. Future-proof: Design for change, not just today's requirements. Choose modern, maintainable architectures and build technical excellence into your culture. Microservices aren't dead. Which of these measures resonates most with your experience? What would you add to this list? Share your thoughts in the comments!

𝟓 𝐒𝐭𝐚𝐠𝐞𝐬 𝐨𝐟 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐫 & Human 𝐑𝐞𝐢𝐧𝐯𝐞𝐧𝐭𝐢𝐨𝐧 (Letting go of code to rediscover the craft) We’ve all noticed it. Everyone uses meeting recorders now, but almost no one reads the notes. Why? Because we didn’t take them ourselves. They lack 𝐢𝐧𝐭𝐞𝐧𝐭, 𝐨𝐰𝐧𝐞𝐫𝐬𝐡𝐢𝐩, and 𝐜𝐨𝐧𝐭𝐞𝐱𝐭. That same pattern is showing up in development. As GenAI writes more of the code, individual lines hold less meaning. The real value is shifting. Not toward faster coding, but toward 𝐛𝐞𝐭𝐭𝐞𝐫 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞𝐬 for the people who use what we build. Here’s how that shift feels, in real life: ▫️ 𝐃𝐞𝐧𝐢𝐚𝐥 – “This won’t affect me” ▪️It’s just autocomplete ▪️I’ll try it when I have time We hold on to the belief that being a dev means typing every line ourselves. ▫️ 𝐀𝐧𝐠𝐞𝐫 – “Why is this thing so wrong” ▪️It breaks patterns. It forgets things. ▪️It feels like cheating. But really, it’s asking us to rethink what precision means. ▫️ 𝐁𝐚𝐫𝐠𝐚𝐢𝐧𝐢𝐧𝐠 – “If I prompt better…” ▪️ We learn. ▪️ We explore. ▪️We adapt. The tools go from frustrating to functional, but something still feels off. ▫️ 𝐃𝐞𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 – “What’s left for me” ▪️ If I’m not writing the code, what am I doing? ▪️If AI handles 90%, am I just approving suggestions? Then comes the pivot… ▫️ 𝐀𝐜𝐜𝐞𝐩𝐭𝐚𝐧𝐜𝐞 – “This is the job now” ▪️We stop focusing on typing and start focusing on 𝐢𝐧𝐭𝐞𝐧𝐭. ▪️We build for 𝐮𝐬𝐞𝐫 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞, not just code correctness. We design for clarity, for flow, for trust. Because once code becomes fast and automatic, the real skill is knowing what to build and how to make it 𝐮𝐬𝐞𝐚𝐛𝐥𝐞. 💡 The best devs today are crafting interfaces, not just logic. 💡 They’re designing outcomes, not just outputs. 💡 They’re becoming 𝐬𝐲𝐬𝐭𝐞𝐦 𝐭𝐡𝐢𝐧𝐤𝐞𝐫𝐬 with a focus on how people interact, not just how machines execute. This is not the end of development. It’s the next level of it. #mindsetchange #ai #genai #enterprise #cio Forbes Technology Council Gartner Peer Experiences InsightJam.com PEX Network Theia Institute IgniteGTM IA FORUM 𝗡𝗼𝘁𝗶𝗰𝗲: The views within any of my posts or newsletters are not those of my employer or the employers of any contributing experts. 𝗟𝗶𝗸𝗲 👍 this? Feel free to reshare, repost, and join the conversation!

I still can’t believe how many Controls Engineers out there won’t even write their code prior to commissioning… let alone test it.   I mean, I can empathize with how demoralizing it is to arrive onsite, with beautiful code in hand, ready to conquer the world - only for the scope to completely change as you walk through the door… I’ve been there myself, more times than I can count.   What I cannot support is the attitude of, “It’s going to change anyway, so why bother?” This mindset is an unhealthy mix of arrogance, apathy, and dejection, often built upon decades of experience with poor, even nonexistent, project management.   Rather than succumb to this defeated state, what can we do?   --- Focus on What We Can Control Scope changes are inevitable, but the effort we put into preparation is completely in our control. Writing and testing our code beforehand might not prevent changes, but it gives us a solid foundation to adapt quickly. Pivoting from a structured starting point is far easier than scrambling to build one under pressure.   --- Expect Change, but Plan for Quality We know things will change - that’s a given. But planning for change doesn’t mean sacrificing quality. Modular, reusable code and simulation environments only make the modifications easier and help ensure that we are delivering value, even though the ever-evolving requirements.   --- Shift Our Mindset This isn’t about writing "perfect" code - it’s about respect for our clients, end users, and craft. Starting with, “Why bother?” sets the stage for mediocrity. Starting with, “How can we be better prepared?” creates opportunities for growth.   --- Fight for Change Blaming poor project management, unclear scopes, or rushed deadlines is easy… but it doesn’t solve our problems. Instead, take charge. If the calls aren’t happening, organize them. Push for reviews with the operators, management, and maintenance teams to uncover potential changes earlier.   Get ahead of the shifts instead of reacting to them. Advocate for what matters: detailed scopes, realistic timelines, and access to simulation environments. Speak up in kickoff meetings, ask thoughtful questions, and document everything. Fighting for change isn’t about pointing fingers - it’s about stepping up to create the structure and clarity our clients deserve. So, while we’ve all been burned by poor planning or surprise changes, it’s how we respond defines us.   How do you balance preparation with the unpredictability of commissioning?   #Automation #Engineering #ContinuousImprovement #ProjectManagement

This one change transformed how we build software. And it’s not what you think. ⬇️ Tweaking Our Process to Build Better. 𝗛𝗲𝗿𝗲'𝘀 𝗵𝗼𝘄 𝘄𝗲 𝗱𝗶𝗱 𝗶𝘁: ● We mapped out our entire workflow ● Identified bottlenecks that were holding us back ● Streamlined every repetitive task. It wasn’t smooth. We hit resistance from the team, and the old ways kept creeping back. But we pushed through by emphasizing small, manageable changes rather than a complete overhaul. 𝗛𝗲𝗿𝗲'𝘀 𝘄𝗵𝗮𝘁 𝘄𝗲 𝗱𝗶𝗱: 1. Automated daily stand-ups → Boosted communication 2. Introduced code review sprints → Improved code quality 3. Switched to feature-based squads → Cut down on dependencies 4. Integrated real-time feedback loops → Better alignment on projects (𝗦𝗵𝗮𝗿𝗶𝗻𝗴 𝘁𝗵𝗲𝘀𝗲 𝘀𝘁𝗲𝗽𝘀 𝗯𝗲𝗰𝗮𝘂𝘀𝗲 𝗶𝘁’𝘀 𝗺𝗼𝗿𝗲 𝗵𝗲𝗹𝗽𝗳𝘂𝗹 𝘁𝗵𝗮𝗻 𝗷𝘂𝘀𝘁 𝘁𝗵𝗲𝗼𝗿𝘆.) ✔️ 𝗞𝗲𝘆 𝗹𝗲𝘀𝘀𝗼𝗻𝘀 𝗹𝗲𝗮𝗿𝗻𝗲𝗱: ● Change management is a process, not a one-time action. ● Communication is the biggest driver of efficiency. ● Teams need time to adapt and trust new workflows. 𝗙𝗼𝗿 𝘁𝗵𝗲 𝗻𝗲𝘅𝘁 𝗾𝘂𝗮𝗿𝘁𝗲𝗿, 𝘄𝗲’𝗿𝗲 𝗳𝗼𝗰𝘂𝘀𝗶𝗻𝗴 𝗼𝗻: ● Expanding automation in testing. ● Offering training for our new process. ● Scaling this approach across all our projects. PS: Let me know in the comments if this resonates, or if you have similar experiences! #softcircles #softwaredevelopment #processimprovement #teamwork #efficiency #devops #changemanagement #agilemethodology #communication #nyc