DEV Community: Abhay Rao

Lessons from Building IBM Bob: What Neel Sundaresan's Journey Reveals

Abhay Rao — Tue, 29 Sep 2026 18:15:57 +0000

Recently, I watched the first episode of Bob TV, hosted by Maximilian Jeesh, featuring Neel Sundaresan, General Manager of Automation and AI at IBM and one of the key leaders behind IBM Bob. What started as a discussion about AI coding assistants quickly evolved into a much broader conversation about software engineering, enterprise innovation, AI adoption, and the future of technical careers.

What struck me most was that very little of the discussion was actually about generating code. Instead, it focused on how AI is changing the way software is designed, maintained, modernized, secured, and delivered. That distinction feels important because much of the public conversation around AI still centers on code completion and productivity metrics. Neel's perspective was that software engineering is undergoing a much deeper transformation.

Long Before AI Coding Was Popular

One of the fascinating parts of the conversation was hearing how Neel started working on AI-assisted development years before the current wave of large language models existed. Today it is easy to assume that AI coding assistants appeared because ChatGPT arrived on the scene, but the reality is much more nuanced.

While working at Microsoft, Neel became interested in the enormous volume of code available across GitHub repositories. His belief was that developers repeatedly write variations of code that already exist somewhere else. If machines could learn patterns from previously written software, perhaps they could help developers by recommending APIs, parameters, and implementation patterns.

At the time there were no frontier models, no trillion-parameter systems, and no transformer-driven coding assistants. The team built recommendation systems using traditional machine learning techniques, and while the accuracy wasn't spectacular by today's standards, developers still found the tool useful because it eliminated friction.

That lesson has remained surprisingly relevant. The goal of AI isn't necessarily perfection. Sometimes simply reducing friction creates value.

Being Too Early Isn't the Same as Being Wrong

Another theme that resonated with me was Neel's attitude toward failed ideas and early experimentation. Many people describe projects that don't immediately succeed as mistakes. His view was that many of those initiatives are actually good ideas that arrive before the supporting technology is ready.

AI for software development is a perfect example. The concept existed years before it became commercially viable. The vision was there long before the GPUs, infrastructure, models, and datasets necessary to support it.

Instead of seeing early failures as wasted effort, Neel viewed them as preparation. By continuing to explore ideas before the technology matured, teams become ready when the environment changes. When foundation models, scalable infrastructure, and modern AI tooling finally arrived, the work that had been done years earlier suddenly became practical.

That mindset applies well beyond AI. Many innovations appear impossible until the surrounding ecosystem catches up.

Building a Startup Inside IBM

One of the questions Max asked was how IBM Bob was created so quickly inside a company with hundreds of thousands of employees.

The answer surprised me.

Bob didn't begin as a massive strategic initiative with huge teams and extensive resources. There was no large organizational structure dedicated exclusively to the project. Instead, the team operated much more like a startup than a traditional enterprise software group.

Neel explained that small teams can move quickly, experiment freely, and recover from mistakes without creating significant organizational disruption. That flexibility allowed the team to test ideas, gather feedback, and iterate rapidly.

An especially interesting detail was that Bob helped build Bob. The team actively used the product while developing it, creating a feedback loop where they could quickly identify weaknesses, improve workflows, and validate new features.

The lesson is clear: innovation often starts small. It doesn't require massive organizations. It requires focused people, a clear goal, and the willingness to learn continuously.

Enterprise AI Is a Different Challenge

The discussion then shifted toward one of the most important distinctions in the AI industry: the difference between consumer AI and enterprise AI.

Many coding assistant demonstrations focus on creating new applications. A user asks an AI to generate a website, an API, or a microservice, and everything looks impressive. However, enterprise software development rarely revolves around greenfield applications.

Most enterprise engineering effort is spent on modernization, migration, maintenance, security, governance, compliance, and integration.

Organizations still run business-critical workloads built over decades. They maintain Java systems that have existed for years. They modernize mainframe applications, migrate infrastructure, address security requirements, and comply with regulatory frameworks.

That reality fundamentally changes what an AI assistant needs to do.

Rather than focusing exclusively on code generation, IBM Bob was designed to help with COBOL modernization, enterprise Java workloads, governance workflows, compliance requirements, migration projects, and other tasks that dominate real-world enterprise engineering.

The AI challenge isn't simply writing code.

The challenge is helping organizations evolve complex systems safely.

Why IBM Bob Doesn't Let You Choose Models

One of the more controversial design decisions discussed was intelligent model routing.

Many AI products emphasize model selection. Users are constantly encouraged to choose between the latest reasoning model, coding model, or thinking model.

Bob takes a different approach.

Instead of asking the user to pick the model, the platform determines which model is most appropriate for the task. Neel compared this to transportation choices: you don't use the same vehicle for every situation.

Some tasks require powerful reasoning models. Others benefit from smaller, faster, and more efficient systems. The optimal choice depends on the problem, not on which model happens to be trending.

To make this work, the Bob team continuously evaluates models across several dimensions:

Accuracy
Latency
Cost
Productivity impact
User experience

The result is a system where developers focus on solving problems while the platform handles the complexity of model selection. As the number of available models continues to grow, this approach seems increasingly relevant.

AI Is Not Replacing Software Engineers

Eventually, the conversation reached one of the most common questions in technology today.

Will AI replace software developers?

Neel's response was straightforward: no. In fact, he argued the opposite.

Many engineering organizations have extensive backlogs filled with projects that have lacked the resources, skills, or time to complete. AI helps teams address those opportunities. When repetitive tasks are automated, engineers can dedicate more energy to solving complex problems.

Neel described this using a simple idea:

Automate the mundane and augment the complicated.

Testing, documentation, boilerplate generation, and repetitive implementation work can often be accelerated by AI. At the same time, system architecture, business logic, evaluation, governance, and decision-making remain deeply human challenges.

The result isn't fewer engineers. It's engineers working on higher-value problems.

A Better Onboarding Experience for New Developers

Another part of the discussion that I found particularly interesting involved junior engineers. Historically, new developers often spent months getting comfortable with a company's codebase, infrastructure, and development practices. Many were hesitant to ask questions because they worried about interrupting senior colleagues, while others simply waited until someone had time to help them.

According to Neel, every new engineering hire at IBM now receives Bob from day one. That dramatically changes the onboarding experience. Instead of waiting for answers, new developers can immediately begin exploring systems, understanding architecture, learning internal terminology, and asking questions as they work.

AI doesn't replace mentorship, but it dramatically increases access to information and guidance. For a new engineer, that means becoming productive faster and building confidence earlier.

What Students Should Focus On

The final section of the discussion focused on the next generation of engineers. A common assumption is that students should now focus on prompt engineering because AI will handle coding. Neel disagreed.

His advice was surprisingly traditional.

Build strong foundations.

Develop analytical thinking.

Understand systems.

Develop expertise in a specific domain.

His reasoning was that AI lowers the barrier to implementation, but domain knowledge remains invaluable. Whether someone works in software engineering, finance, healthcare, manufacturing, or law, understanding the problem space becomes increasingly important.

Programming languages become easier to access.

Expertise becomes harder to replace.

The people who thrive in the AI era will likely be those who combine domain knowledge, critical thinking, and AI-assisted workflows.

References

Bob TV – Episode 1

Host: Maximilian Jesch, Outbound Product Manager for IBM Bob
Guest: Neel Sundaresan, General Manager of Automation and AI at IBM

Topics discussed included:

The history of AI-assisted software development
Building IBM Bob inside IBM
Enterprise AI versus consumer AI
Intelligent model routing
The future of software engineering
AI and developer productivity
Skills students should focus on in the AI era

Credit: Full credit to Maximilian Jesch and Neel Sundaresan for the original Bob TV conversation and the insights shared throughout the session. This article is a paraphrased interpretation and summary of the discussion.

What Developers Are Saying About IBM Bob #9

Abhay Rao — Tue, 29 Sep 2026 09:34:17 +0000

One of the most interesting aspects of AI-assisted development is not just how fast code can be generated, but how effectively teams can move from an idea to a deployed solution.

That's why this feedback from Shigehiro Mouri, General Manager at System Research, stood out to me.

"We built an application that processes video frames in parallel using OCR. By working closely with Bob, we were able to move smoothly from design to environment setup and deployment, resulting in significant improvements in both implementation accuracy and development speed."

What I find compelling about this example is that it goes beyond code generation. Building an OCR-based application that processes video frames in parallel involves multiple stages, including architecture decisions, environment configuration, implementation, testing, and deployment.

Many AI tools are evaluated based on how quickly they can produce code snippets. However, real-world projects often require much more than coding. Teams need assistance understanding requirements, configuring environments, solving integration challenges, and maintaining momentum throughout the delivery process.

This feedback highlights how IBM Bob can support developers across those stages, helping reduce friction between planning and execution. The value isn't simply writing code faster. It's enabling teams to move through the entire development lifecycle more efficiently while maintaining accuracy and quality.

As AI adoption continues to grow, the biggest productivity gains may come from accelerating complete workflows rather than individual tasks.

From Business Requirements to Production-Ready AI Agents with IBM Bob and watsonx Orchestrate

Abhay Rao — Tue, 29 Sep 2026 05:20:55 +0000

One of the biggest challenges in enterprise AI isn't building an agent. It's transforming a business requirement into a solution that is testable, maintainable, secure, and ready for production.

That's what makes the tutorial by Ahmed Azraq and Allen Chan so interesting. Instead of starting with code, the workflow starts with a Business Requirements Document (BRD) and demonstrates how teams can use IBM Bob together with watsonx Orchestrate to generate a complete agentic solution from end to end.

Original tutorial:
Build AI agents from business requirements with IBM Bob and watsonx Orchestrate

What stood out is that the tutorial follows a process that closely resembles how enterprise software is actually delivered. Rather than prompting for isolated code snippets, the focus is on progressively moving from requirements to architecture, implementation, testing, and deployment.

Starting with Business Requirements

The journey begins by launching IBM Bob from watsonx Orchestrate and preparing the development environment.

This includes configuring the watsonx Orchestrate ADK, connecting MCP servers for documentation search and environment management, and loading specialized skills such as sop-builder and wxo-builder.

The objective isn't to immediately generate code. The objective is to first understand the business problem and establish a structured implementation plan.

This is where many AI projects struggle today. Organizations often have detailed business requirements, but there is a significant gap between those requirements and production-ready implementation.

Turning a BRD into an SOP

One of the most impressive parts of the tutorial is the conversion of a Business Requirements Document into a detailed Standard Operating Procedure (SOP).

The generated SOP becomes the central source of truth for the entire project and includes:

Process flows
Decision trees
Exception handling logic
Test scenarios
Acceptance criteria
Validation requirements

Instead of developers interpreting requirements differently, the SOP provides a shared foundation that both humans and AI agents can reference throughout implementation.

The result is improved consistency and reduced ambiguity.

Building Specialized AI Agents

Once the requirements have been structured, IBM Bob begins constructing the solution itself.

The tutorial demonstrates building an incident management system powered by five specialized AI agents. Rather than relying on a single agent to perform every task, responsibilities are divided among focused agents.

This mirrors how enterprise teams operate in real life.

Some agents focus on investigation.
Others focus on triage.
Others handle orchestration and resolution workflows.

Breaking complex processes into smaller agent responsibilities makes the overall system easier to understand, maintain, and scale.

Creating Tools and Business Actions

Enterprise agents become truly useful when they can interact with business systems.

The tutorial walks through creating Python-based tools capable of performing actions such as:

Creating support tickets
Initiating remediation workflows
Supporting incident resolution processes
Automating operational activities

This moves agents beyond simple conversational assistants and into systems that can actively participate in business processes.

Building a Knowledge Foundation

Another important component is the creation of a runbook-backed knowledge base.

This allows agents to retrieve information from trusted sources rather than relying solely on model-generated responses.

The knowledge layer contains:

Resolution procedures
Operational guidance
Troubleshooting documentation
Best practices
Support workflows

This approach improves consistency while reducing the risk of inaccurate responses.

Validation Before Deployment

A theme throughout the tutorial is that generating agents is only part of the journey.

Validation is equally important.

The workflow includes:

Automated unit tests
Smoke testing
Agent instruction evaluation
Quality assessment
Production-readiness reviews

This is especially important in enterprise environments where reliability matters just as much as innovation. An AI-generated solution that cannot be validated should not reach production.

Documentation and Governance

The workflow also generates architecture artifacts and implementation reports.

That might not sound exciting, but documentation is one of the most overlooked parts of modern software development. By automatically producing implementation reports and architectural documentation, teams gain:

Better traceability
Knowledge retention
Easier onboarding
Improved governance
Stronger compliance alignment

The Bigger Picture

What makes this tutorial compelling is that it shifts the focus away from code generation and toward solution generation.

The workflow becomes:

Business Requirement
        ↓
SOP Generation
        ↓
Agent Design
        ↓
Tool Creation
        ↓
Knowledge Integration
        ↓
Testing & Validation
        ↓
Deployment

This is very different from the traditional AI workflow of simply prompting for code.

Instead, it demonstrates how AI can participate throughout the software delivery lifecycle.

Final Thoughts

The biggest takeaway for me is that enterprise AI is gradually evolving beyond coding assistance.

IBM Bob and watsonx Orchestrate show how organizations can transform business requirements into tested, documented, and deployable agentic solutions.

The value isn't just writing code faster.

It's reducing the distance between business intent and production software.

As agentic development matures, this kind of end-to-end workflow may become one of the most important applications of AI in enterprise software engineering.

Credit: Full credit to Ahmed Azraq and Allen Chan for the original tutorial, Build AI Agents from Business Requirements with IBM Bob and watsonx Orchestrate, which inspired and informed this summary.

From Code Assistant to Maximo Gateway: Exploring IBM Bob on Real Maximo Challenges

Abhay Rao — Mon, 28 Sep 2026 17:38:01 +0000

One of the most valuable observations from Yann Bordelanne's deep dive into IBM Bob is that the conversation around AI is evolving.

The real question is no longer:

Can AI generate code?

The more meaningful question is:

How can AI help technical teams solve real-world problems more effectively?

To answer that, Yann evaluated IBM Bob against practical IBM Maximo scenarios that developers, administrators, and consultants encounter daily. Rather than focusing on simple code generation, he explored how Bob could support troubleshooting, automation, documentation, configuration management, integration design, and eventually direct interaction with Maximo itself.

Context Matters More Than Prompts

One lesson appeared repeatedly throughout the article:

The quality of the output depends heavily on the quality of the context provided.

When Bob was asked to generate a simple SQL script, it produced a technically reasonable response. However, when supplied with additional information such as work order details, business rules, naming conventions, and existing internal scripts, the quality and relevance of the response increased significantly.

The same pattern appeared across multiple areas:

SQL generation
Configuration changes
Report modifications
Automation scripting
Integration planning

Good context transformed generic answers into practical deliverables.

Real Maximo Use Cases

Yann tested IBM Bob against several common Maximo tasks.

Working with BIRT Reports

Maintaining BIRT reports often requires navigating unfamiliar datasets and report structures.

Bob helped identify components, understand report logic, and suggest modifications such as:

Replacing existing information
Removing report elements
Adding indicators and counters
Updating report layouts

While human review remains essential, AI can reduce the time spent exploring report structures.

XML Configuration Changes

Application XML files can be complex and difficult to navigate.

Bob was used to locate specific controls, understand surrounding structures, and assist with modifications such as adding fields or changing layouts.

Even small XML updates become easier when the assistant understands the broader structure of the configuration.

Log Analysis and Troubleshooting

One particularly interesting scenario involved investigating a Java library conflict.

Instead of manually reviewing extensive error logs, Bob helped identify:

Dependency issues
Class-loading conflicts
Repeating exceptions
Potential root causes

This doesn't replace experienced engineers, but it can accelerate the early stages of troubleshooting.

Python and Jython Automation

Maximo teams frequently need to translate existing business logic into automation scripts.

By providing Java implementations as context, Bob was able to assist with the creation of Python and Jython automation scripts that align with Maximo conventions.

Moving Beyond Code: MCP and Maximo Integration

Perhaps the most exciting part of the article explores the future potential of IBM Bob through the Model Context Protocol (MCP).

Instead of simply generating Maximo-related code, Bob could potentially interact directly with authorized Maximo capabilities.

Using Maximo Application Suite 9.2 MCP support, future workflows could include requests such as:

Show the status of a work order
Find open work orders for an asset
Create service requests
Update work order status
Create follow-up work orders
Record meter readings

The workflow becomes:

User Request
        ↓
IBM Bob
        ↓
Maximo MCP Server
        ↓
Authorized Maximo Tool
        ↓
Validation & Security Checks
        ↓
Result or Approved Action

The important detail is that actions remain governed by Maximo's existing business logic, security controls, permissions, and validation mechanisms.

Security and Governance Matter

A major theme throughout Yann's analysis is responsible AI adoption.

Direct database access is rarely the right approach.

Instead, Bob should interact through:

Authorized APIs
Object Structures
Automation Scripts
Controlled MCP Tools
Business Workflows

Additional safeguards include:

Least-privilege access
Explicit approval steps
Identity-based permissions
Audit logging
Secure authentication
Human review for critical changes

This ensures AI becomes a controlled participant in enterprise workflows rather than an unrestricted actor.

My Biggest Takeaway

What I found most interesting about Yann's article is that it frames IBM Bob as an augmentation tool rather than a replacement for developers, consultants, administrators, or architects.

Today, Bob can assist with:

Understanding unfamiliar systems
Generating scripts
Updating configurations
Investigating errors
Planning integrations
Producing documentation

Tomorrow, through MCP and controlled enterprise integrations, it may also become a conversational gateway to business systems themselves.

The future of AI in enterprise software isn't just about generating better code.

It's about combining:

Context + Tools + Governance + Human Validation

to create meaningful business value.

For Maximo environments, the combination of IBM Bob, MCP, and secure enterprise controls offers a compelling glimpse into what agentic enterprise management could look like.

Credit: Full credit to Yann Bordelanne for the original article, hands-on experimentation, and detailed exploration of IBM Bob across real IBM Maximo scenarios. This post is a summarized and paraphrased interpretation of his findings and insights.

What Developers Are Saying About IBM Bob #8

Abhay Rao — Mon, 28 Sep 2026 09:33:37 +0000

One of the biggest concerns organizations have when adopting AI for software development is trust.

Can the tool stay within defined boundaries? Will it generate reliable answers? Can teams confidently use it in enterprise environments where accuracy matters?

That's why this perspective from Steve Cast, Regional Lead - Practice Director at Fresche Solutions, caught my attention.

"Bob has built-in guardrails. It operates in different modes, allowing you to approve its suggestions before any changes are made to your source code. If you ask it about a non-existent RPG op-code, it won't 'hallucinate' an answer; it will simply state that it doesn't understand. This controlled, predictable behavior is crucial for enterprise development."

What stands out here is the emphasis on predictability rather than raw generation speed.

For enterprise teams working with critical systems, especially technologies like RPG, COBOL, and IBM i, the ability to review, validate, and control changes is often more important than generating code quickly.

AI becomes significantly more valuable when it understands its limits, respects guardrails, and supports developer oversight.

As organizations continue adopting agentic development tools, trust, governance, and transparency may ultimately matter just as much as productivity gains. The best AI assistant isn't necessarily the one that always answers. It's the one that knows when not to.

Bobalytics: Understanding the Real Impact of AI Across Your Enterprise

Abhay Rao — Mon, 28 Sep 2026 05:18:25 +0000

As AI adoption grows, one question becomes increasingly important:

How do you measure whether AI is actually delivering value?

It's easy to track prompts and code generation. It's much harder to understand the impact AI has on software delivery, team productivity, adoption, and business outcomes.

That's where Bobalytics comes in.

Bobalytics is IBM Bob's analytics and insights capability, designed to help organizations understand how AI is being used across development teams and how that usage translates into measurable value. According to presentations from Neal Whittle, Bobalytics serves as a comprehensive view into Bob's contribution across the software delivery lifecycle. 【1-52af4c】

With Bobalytics, organizations can gain visibility into:

Bob's contribution to development activities
Team and enterprise adoption trends
Usage patterns across projects and users
Bobcoin consumption and allocation
Productivity and value metrics
AI utilization across teams and departments
Areas where agentic workflows are creating the biggest impact

What makes this especially valuable for enterprises is that it moves the conversation beyond AI experimentation.

Instead of asking:

Are people using AI?

Organizations can start asking:

Which teams are generating the most value?
Where are productivity gains occurring?
How is AI adoption evolving?
What business outcomes are being achieved?

Bobalytics is also positioned as an enterprise differentiator because it helps leaders manage adoption, track spending, optimize usage, and demonstrate ROI from AI investments. Combined with enterprise governance, administration controls, and shared Bobcoin management, it provides visibility that extends beyond individual developers.

As agentic development becomes more common, analytics will be just as important as the agents themselves.

The real goal isn't measuring prompts. It's measuring outcomes.

Usage → Adoption → Productivity → Business Value

That's the story Bobalytics aims to tell.

Bobalytics as a key capability for understanding AI adoption, productivity, and business value across the enterprise.

From a 2-Week Prototype to a Weekend Project: A Real-World IBM Bob Story

Abhay Rao — Sun, 27 Sep 2026 18:00:58 +0000

One of the most compelling use cases for AI in software engineering isn't generating code from scratch. It's helping experienced teams turn domain expertise into reusable solutions faster.

A great example comes from Novadoc ECM BV, a Netherlands-based consultancy working with IBM FileNet environments.

The team was dealing with a familiar challenge. Many FileNet configuration activities were still manual, repetitive, and carried operational risk. Novadoc already understood the problem deeply and had the expertise to improve the process. The missing piece wasn't knowledge. It was the engineering bandwidth needed to automate and productize the solution.

That's where IBM Bob entered the picture.

According to the case study, a developer started with a partially completed framework on a Friday and delivered a working application by Monday. A task that was expected to take roughly two weeks was condensed into a single weekend.

What I find particularly interesting isn't just the speed improvement. The bigger outcome was the creation of a reusable solution.

Instead of repeating the same manual effort for every customer engagement, Novadoc now has a foundation they can deploy, adapt, and extend across multiple projects. That's where the value compounds over time.

The story also highlights how IBM Bob contributed beyond code generation. The team used it to:

Document a legacy codebase
Improve architectural decisions
Accelerate application development
Create a reusable framework for future work

This reflects a broader trend I'm seeing with agentic development tools. The biggest gains often come from helping teams transform expertise into repeatable processes rather than simply writing code faster.

In many organizations, the real bottleneck isn't knowledge. It's turning that knowledge into scalable, reusable solutions.

And that's exactly where this story becomes interesting.

📖 Read the full story: Novadoc ECM BV Case Study

What Developers Are Saying About IBM Bob #7

Abhay Rao — Sun, 27 Sep 2026 17:58:40 +0000

One of the most common promises made by AI coding tools is speed. But speed alone isn't enough. Developers also expect solutions that understand context, make sensible decisions, and help them build real-world systems with minimal back-and-forth.

That's why this feedback from Wesley Wienen, Technical Presale Engineer at Appsys ICT Group, stood out to me.

"Project Bob sounds so wonderfully innocent but it is incredibly powerful. 3 prompts. That's all it took to build a production-ready MCP server. Project Bob blew my expectations out of the water. Bob delivers the kind of work you'd expect from an experienced developer who actually thinks about the full picture."

What I find interesting is the emphasis on outcomes rather than prompts. Building a production-ready MCP server isn't simply about generating code. It requires understanding integration points, implementation details, and how the pieces fit together.

As AI tools evolve, the biggest productivity gains may come from reducing the amount of guidance required while still producing high-quality results. The goal isn't just faster generation. It's helping developers move from idea to implementation with fewer iterations and more confidence.

For developers exploring agentic workflows, that's a glimpse of what AI-assisted software development can look like when context, reasoning, and execution come together.

Running Your Own LLM Locally with vLLM: A Practical Introduction

Abhay Rao — Sun, 27 Sep 2026 17:56:27 +0000

As AI adoption grows, more developers are asking an interesting question:

What if I could run an LLM on my own infrastructure?

In a recent tutorial, IBM's Cedric Clyburn walks through how to self-host and serve open-weight language models using vLLM, one of the most popular high-performance inference engines for LLM deployment.

The session covers much more than simply loading a model. It explores the practical considerations that matter when running AI locally, including GPU memory requirements, quantization strategies, inference performance, and API-based model serving.

Some of the topics covered include:

What vLLM is and why it is becoming popular for AI inference
Continuous Batching and Paged Attention concepts
Running LLMs directly from Python
Serving models through API endpoints
Offline inference workflows
Deploying and evaluating AI models in production environments

What I particularly like about this type of content is that it moves beyond prompting and into AI infrastructure. Understanding how models are deployed, optimized, and served gives developers a much deeper appreciation of what's happening behind the scenes.

Whether you're experimenting with local AI, evaluating self-hosted deployments, or trying to understand the trade-offs between cloud and on-premise inference, vLLM provides a practical starting point.

And while exploring self-hosted AI deployments, tools like IBM Bob can help accelerate development workflows, allowing you to focus more on building and integrating AI-powered applications.

🎥 Watch the tutorial: vLLM Self-Hosting Walkthrough

💻 Explore the accompanying code: Project Repository

🚀 Try IBM Bob: Start Free Trial

Why IBM Bob Is Being Talked About as More Than Just a Coding Assistant

Abhay Rao — Sat, 26 Sep 2026 16:54:33 +0000

I recently went through an excellent slideshow by Neal Whittle on IBM Bob, and one of the key takeaways was that the conversation around AI development tools is starting to evolve.

For a while, the focus has been on code generation speed. Can AI write code faster? Can it complete functions? Can it generate tests?

Neal's presentation argues that the bigger opportunity is much broader.

IBM Bob is positioned not simply as a coding assistant, but as a platform that can help organizations modernize applications, improve developer productivity, strengthen governance, and make better business decisions across the software lifecycle.

What stood out to me was the combination of familiar developer experiences and enterprise-focused capabilities. Bob is built on VS Code compatibility, allowing developers to keep existing extensions, workflows, debugging tools, and development habits while gaining access to AI-native capabilities.

The presentation also highlights Bob's deep integration with the IBM ecosystem, including technologies such as Watsonx, IBM i, IBM Z, OpenShift, Db2, MQ, Guardium, Concert, Apptio, and Cloud Pak products. For organizations already invested in IBM technologies, that native understanding can be a significant differentiator.

Another area that caught my attention was Bob's support for technologies that remain critical in many enterprises, including RPG, COBOL, JCL, CICS, IMS, Db2, MQ, and RACF. Modernization isn't always about building something new. Often it's about helping teams evolve and maintain systems that have been powering businesses for decades.

The slideshow also explores capabilities such as:

Agentic development
Bob Shell
Literate Coding
MCP integration
Skills and workflows
Enterprise analytics through Bobalytics
Governance and security controls
Premium modernization packages for Java, IBM i, and IBM Z

All of these contribute to a broader vision of AI-assisted software delivery.

My favorite takeaway comes from the final business perspective:

The goal is no longer just generating code. The goal is delivering measurable business outcomes.

Questions like:

Which applications should we modernize first?
What is the expected ROI?
Which workloads are best suited for AI?
Where are the highest risks?
Which teams are creating the most value?

are ultimately the questions enterprise leaders care about most.

That's why this presentation resonated with me. It shifts the discussion from AI-assisted coding toward AI-assisted enterprise transformation.

📖 View Neal Whittle's slideshow: IBM Bob Enterprise Transformation Presentation

Credit: Full credit to Neal Whittle for creating this presentation and doing a great job outlining why IBM Bob is gaining attention and the value it can bring to enterprise transformation. The ideas summarized here are based on his original slideshow.

What Developers Are Saying About IBM Bob #6

Abhay Rao — Sat, 26 Sep 2026 14:25:38 +0000

One of the biggest challenges for enterprise engineering teams isn't building new applications. It's modernizing legacy systems, maintaining compliance requirements, and delivering software at scale without introducing unnecessary risk.

That's why this perspective from Hans Boef, Manager Technical Consultants and Support at Novadoc, stood out to me.

"Project Bob isn't just another AI assistant. It's an agentic AI development partner built for large organizations tackling complex challenges like modernizing legacy systems, ensuring compliance (HIPAA, FedRAMP), or scaling secure software delivery."

What I find interesting is the focus on organizational challenges rather than individual productivity alone. Large enterprises often have to balance modernization initiatives with governance, security requirements, and regulatory compliance. Success isn't simply about generating code faster.

It's about helping teams navigate complex environments while maintaining quality, security, and operational control.

As AI continues to evolve, the most impactful use cases may come from supporting entire engineering organizations, not just individual developers. Modernization, compliance, software delivery, and governance all become part of the same workflow.

That's where agentic development platforms like IBM Bob can play a meaningful role.

Modernize a Node.js Application with IBM Bob

Abhay Rao — Sat, 26 Sep 2026 14:16:56 +0000

Modernizing legacy applications can be challenging, especially when upgrading runtime versions, containerizing workloads, and addressing technical debt. With IBM Bob, developers can accelerate this process using AI-assisted workflows that combine code understanding, analysis, and automated implementation.

Start by downloading IBM Bob for free from the official page: Download IBM Bob.

To begin the modernization journey, switch IBM Bob to Agent Mode and create a Dockerfile for the application. Bob can help generate the containerized environment, identify dependencies, and prepare the project for modern deployment workflows.

Next, verify that the legacy application builds successfully. During this phase, IBM Bob can analyze build failures and provide recommendations. For example, if the Dockerfile uses npm ci but the project does not contain a package-lock.json file, Bob will highlight the issue and suggest the appropriate fix so the build can proceed.

Before making changes to the codebase, switch to Ask Mode to safely explore the application. Ask Mode is read-only, allowing you to inspect files, understand architecture, review dependencies, and learn how different components interact without modifying source code.

Once you're familiar with the project, return to Agent Mode and begin the modernization process. IBM Bob can assist in upgrading a Node.js Express API from Node.js 16 to Node.js 22, updating dependencies, resolving compatibility issues, improving configurations, and validating the application throughout the migration.

Whether you're modernizing a small service or a larger enterprise application, IBM Bob provides guided AI assistance to help reduce effort and increase confidence throughout the upgrade process.

📖 Learn from the tutorial: Modernize a Node.js Application with IBM Bob