Building Apps with IBM Bob, Your AI Development Partner

26 May 2026 - Seigo TANAKA

Event date: May 25, 2026
Updated 5/27 based on AI meeting notes

JICUG IBM Bob Use Case Event: Building Apps with IBM Bob, Your AI Development Partner

Post Summary

JICUG / Building Apps with IBM Bob - posfie

Decisions

JICUG will keep IBM Bob and related topics as an ongoing theme for future activities.
The next event is planned for June 30, held once a month.
The next theme will focus on using AI for infrastructure work.

Discussion Points

1. About JICUG (Community Introduction)

JICUG stands for Japan IBM Cloud User Group, a community run by users of IBM Cloud.
Unlike events hosted by IBM itself, this is a place for users to share their own experiences using IBM products.
Anyone interested can join, whether or not they currently use or have a contract with IBM Cloud.
The theme for 2026 is AI, especially IBM Bob.
Today’s event had three talks: (1) Tanaka-san — getting started with IBM Bob, (2) Kano-san — building an app with IBM Bob, and (3) Nishikawa-san — using IBM Bob for infrastructure as code (IaC).

2. Talk 1: Trying the IBM Bob Free Trial (Tanaka-san)

Speaker profile: Freelance engineer focused on web frontend work, and an IBM Champion.
Background: He learned about IBM Bob shortly before Golden Week and started the free trial.
Installation steps:
- Started the free trial from IBM’s official page and logged in with an existing IBM account.
- The 30-day trial comes with 40 Bob coins.
- Downloaded and installed the Windows installer without any major issues.
- On first launch, he was asked whether to migrate VS Code settings, but this could be skipped.
- Authenticated his IBM account through the browser to link it with the IDE.
What he liked:
- The UI feels similar to VS Code, so it was easy to get used to.
- Japanese text input is very stable. Other CLI-based coding agents sometimes garble Japanese input, but this wasn’t an issue with IBM Bob.
- Project management felt solid — for example, session history is kept separate when a folder is renamed.
Testing his own “handover management system”:
- He confirmed that his own system, which automatically creates handover files and notes between AI sessions, works with IBM Bob.
- An instruction (in Markdown) to fetch and set up a template from a GitHub repo via NPX worked correctly.
- Reading a roughly 41-line Markdown instruction file used a small amount of Bob coins, about 0.05–0.17 coins.
- He confirmed the same kind of workflow used with Claude Code or Cursor is possible here too.
Summary:
- Installation is quick if you already have an IBM account.
- Stable Japanese input and a familiar VS Code-like feel were the main highlights.
- The same Markdown instruction-file workflow used with other coding agents works with IBM Bob.

3. Talk 2: Building an Observability Training App with IBM Bob (Kano-san)

Speaker profile: Works on multi-cloud and hybrid-cloud managed services, an IBM Champion and Datadog Ambassador, and also runs a programming class for children.
Background and challenge:
- As multi-cloud operations grow, observability skills are becoming more important, and there’s an urgent need to train engineers.
- Classroom learning alone isn’t enough — a training app where people can actually experience failures is needed.
- Since he didn’t want to spend too much time building the app itself, he decided to use AI.
App requirements:
- A three-tier architecture (web server, API server, DB server), containerized on Ubuntu Server.
- A Showa-retro-style flash quiz app: questions are stored in the database, the API handles login and answer checking, and the UI is shown in a web browser.
- Built-in random failures (about 5% of the time) such as database inconsistencies, API delays, and validation errors.
Development flow with IBM Bob:
1. Used Plan mode to turn a 31-line requirements doc into a design document.
2. Switched to Code mode for implementation (setting up containers, Nginx, MySQL, etc.).
3. Implementation proceeded almost continuously, with few interruptions for questions.
4. Fixed bugs such as port conflicts, garbled text, and mismatched Datadog settings.
Comparing Claude Code and IBM Bob:
- He gave both tools the same 31-line requirements doc and the same prompt to create a design.
- Claude Code: asked 2 questions (how to implement the frontend, how to start the containers) and produced an 800-line basic design.
- IBM Bob: asked 3 questions (frontend technology, scope of observability features, container setup) and produced a 700-line basic design.
- Design document quality: IBM Bob stood out for automatically generating detailed documents, including API training steps, frontend specs, and a usage guide.
- Implementation phase: IBM Bob showed progress step by step in fine detail, making it easy to see the overall picture.
- Infrastructure integration: There were small differences in areas not visible to the AI, such as deploying to the server via GitHub.
- Overall: Both tools produced roughly equivalent results. IBM Bob’s strength is handling “plan → implement → verify” as one continuous flow.
Results:
- A training app that was expected to take several months was finished in about two days.
- Observability monitoring (containers, application, database, and user activity) was implemented using Datadog and IBM Instana.
- A real training session was held using the app, successfully meeting the goal.
Demo (participants used the app):
- Participants accessed the flash quiz and triggered intentional errors, such as validation errors.
- The Datadog dashboard showed real-time access counts, errors, and container resource usage (CPU, memory, network).
- 11 accesses and several validation errors (from a nickname-length rule requiring at least 8 bytes) were confirmed in the logs.
Future plans: Deploying on IBM Cloud and using IBM services such as Db2 and Code Engine.

4. Talk 3: Deploying Node-RED to IBM Cloud Code Engine with Terraform, Using IBM Bob and the IaC Spec Kit (Nishikawa-san)

Speaker profile: An IBM Champion for 10 years, a university associate professor teaching cloud and IaC, and also runs corporate training sessions.
Overview of Infrastructure as Code (IaC):
- Defining and managing infrastructure as code improves reproducibility, reduces cost, tracks change history, and makes sharing across teams easier.
- This is often more efficient than using a browser GUI, especially for services like Sakura Cloud where GUI operations can be cumbersome.
- Major tools include Terraform (HashiCorp) and AWS CloudFormation.
- He noted it’s interesting that HashiCorp, the maker of Terraform, is now part of the IBM group, putting major IaC tools under IBM’s umbrella.
Basic Terraform workflow:
- Define resources in .tf files → terraform init (setup) → terraform plan (preview) → terraform apply (deploy) → terraform destroy (remove).
Combining IBM Bob with the IaC Spec Kit:
- He used IBM’s publicly available “IaC Spec Kit” on GitHub, a spec-driven development template made for IaC.
- He confirmed the IaC Spec Kit supports IBM Bob.
- Environment: installed Terraform and the IBM Cloud CLI inside WSL (Ubuntu) on Windows, and launched IBM Bob with the bobide command.
- An IBM Cloud API key and resource group name need to be prepared in advance.
What he did, and what he learned:
- Used ispec init to set up the project, choosing IBM Bob as the AI assistant.
- Used the ispec command to define the spec interactively, then ispec plan to generate a detailed design.
- He recommends turning off auto-approval so each action by IBM Bob can be checked one at a time, to avoid unintended operations.
- Some samples in the IaC Spec Kit, like WordPress, include resources that incur charges, so it’s important to read the documentation carefully (he himself was charged unexpectedly).
- In hindsight, he found it more efficient to prepare the implementation plan (spec) separately, using another tool such as a Granite model, before handing it to IBM Bob.
- He’s currently continuing to test combining a Granite model (4.1, etc.) with IBM Bob.
- With the finished configuration files, he confirmed that Node-RED runs successfully on Code Engine, noting that memory allocation and other settings need to be specified carefully.

5. General Discussion (Ask the Speakers)

Bob coin rollover and reset:
- Coins reset not at the end of the month but on the contract’s anniversary date.
- Unused coins likely do not carry over, so it’s best to use them up.
- One participant still had 90% of their monthly allowance left, even after using Terraform fairly heavily.
Bob coin pricing:
- The exact cost per coin isn’t clearly stated, but according to an outside article, a small app (Node.js, no page transitions, simple CRUD) costs around 2–2.5 coins.
- With 40 coins, you can build several small-to-medium apps.
- Tanaka-san’s 41-line instruction file only used about 0.05–0.17 coins to read.
- When asked directly, IBM Bob gave a rough estimate suggesting the trial’s coin allowance is worth around 1,000–1,500 yen.
Choosing between Claude Code, GitHub Copilot, and IBM Bob:
- Many participants mainly use Claude Code, since it handles design through coding smoothly in one flow.
- GitHub Copilot is used for smaller questions and code review.
- IBM Bob feels similar to Claude Code, with strong design-document and documentation generation.
- Kano-san said IBM Bob “felt closer to Claude Code” and plans to use this as evidence when explaining it internally at his company.
About the underlying model:
- It’s not clearly disclosed which AI model (Granite, Llama, etc.) IBM Bob uses internally.
- Claude is used in some form, but direct questions about other models don’t always get a clear answer.
- It’s possible multiple models are selected and used as sub-agents.
Using auto-approval mode:
- Nishikawa-san recommends turning off auto-approval for IaC work involving billable resources, checking each step one by one.
- Kano-san said for app development, turning auto-approval on and letting it build everything at once is more efficient — a noticeable difference compared to earlier tools like Copilot.
- Infrastructure and database operations (especially DELETE or SELECT) carry a risk of the AI going off track, so caution is needed.
- Without some background in systems and infrastructure, it can be hard to notice when the AI has gone wrong.
SSH and file transfer:
- To connect from a local Windows machine to a remote server, he used PowerShell’s SSH command via instructions to IBM Bob.
- File transfer (e.g. SCP) can also be requested through IBM Bob, but direct operations on production environments should be handled carefully.
How IBM Bob can be used (IDE, CLI, etc.):
- Besides the IDE, IBM Bob can also reportedly be used via CLI, though this wasn’t tested in detail.
- It seems the frontend differs, but the underlying environment is shared.

JICUG Community Introduction and Today’s Agenda

JICUG (Japan IBM Cloud User Group) is a community run by and for users of IBM Cloud, separate from official IBM-hosted events.
It’s open to anyone interested in IBM Cloud or AI, regardless of whether they currently use or have a contract with IBM Cloud.
This year’s theme is AI, with the goal of spreading awareness and excitement around IBM Bob and related technologies.
The community aims to grow by having users share technical knowledge and build connections with one another.
Today’s agenda had three sessions: Tanaka-san’s report on trying the IBM Bob free trial, Kano-san’s case study on app development, and Nishikawa-san’s experience building infrastructure with IaC and IBM Bob.
Each talk ran about 15 minutes, followed by an open discussion (“Ask the Speakers”) at the end.

Tanaka-san: First Impressions of the IBM Bob Free Trial

Masugo Tanaka is a freelance engineer working mainly on web frontend, generative AI, IoT, and XR, and is also an IBM Champion.
He started looking into IBM Bob shortly before Golden Week, and since he already had an IBM account, he was able to start the 30-day free trial smoothly.
Installation was simple, and launching the VS Code-like UI felt almost identical to his usual development environment, which he rated highly.
He especially emphasized that Japanese text input (IME) was very stable, without the input glitches or garbled text seen in some other coding-agent tools.
He tested his own “handover management system” (a Markdown-based mechanism for passing notes and knowledge between AI sessions) with IBM Bob, and the flow of fetching and setting up a template via NPX worked correctly.
IBM Bob correctly understood his Markdown instruction file (about one to two pages), including calling help files and generating handover notes as intended, while using only a small amount of Bob coins.
He plans to keep using it for prototyping and early-stage (“0 to 1”) development, since the same workflow used with other coding agents like Claude Code and Cursor works here too.

Moderator (Kano-san): Building an Observability Training App with IBM Bob

He works on multi-cloud and hybrid-cloud managed services, where training engineers in observability — visibility across the UI, app, database, and infrastructure — has been a challenge.
Classroom learning alone isn’t enough; an actual working app is needed to let people experience and analyze failures. But building a three-tier app (web, API, and DB servers) normally takes a lot of time.
To save time, he decided to use AI: he first built a version with Claude Code and GitHub Copilot, the tools he normally uses, then rebuilt the same flash-quiz app with IBM Bob.
Comparing IBM Bob and Claude Code with the same requirements document and the same prompt gave him a good opportunity to directly measure the differences between the two tools.
The app he built, “Flash Quiz,” stores Showa-era trivia questions in a database, handles login and answer retrieval through an API server, and displays everything in a web browser — a three-tier containerized app.
The app includes intentional failures (database inconsistencies, API delays, validation errors, etc.), designed as training material to be observed and analyzed with observability tools.

Moderator (Kano-san): Comparing Claude Code and IBM Bob

Design and Implementation Phase

Starting from a 31-line requirements document, Claude Code asked only 2 questions and produced an 800-line basic design, while IBM Bob asked 3 questions (about the frontend, observability scope, and container setup) and produced a roughly 700-line design.
After finishing the design, Claude Code let him choose between moving straight to implementation or doing a more detailed design first; for implementation, it broke the work into 5 phases and coded through them continuously.
IBM Bob listed out detailed to-do tasks before implementation and visualized progress step by step, which made the overall process easy to follow.
He rated IBM Bob highly for generating thorough supporting documents, including API training steps, frontend specs, and a usage guide.
Bugs that came up included port conflicts, garbled Japanese text, and mismatched Datadog settings — issues he traced back to gaps in the original requirements document.
An observability training tool that would normally take several months was finished in about two days using AI, showing the value of dividing roles between Claude Code, Copilot, and IBM Bob.

Results and Observability Demo

The finished system runs as four containers — web server, API server, DB server, plus a Datadog agent container — enabling full monitoring.
He shared the flash-quiz URL with participants and had them access it in real time, demonstrating how Datadog’s dashboard immediately visualized 11 accesses and several errors.
He showed that even though a username needed at least 8 bytes, a 4-character entry triggered a validation error, and the full details could be checked remotely through the dashboard.
The Datadog dashboard showed real-time CPU, memory, network, and disk usage for the web, API, and DB containers, with load changes visible as participants accessed the app.
He also mentioned that similar monitoring is possible with tools like IBM Instana, and that he’s considering moving to IBM Cloud and using services like Code Engine and Db2 going forward.
He highlighted IBM Bob’s strength as handling “plan, implement, and verify” all in one continuous flow — supporting everything from filling knowledge gaps to implementation and testing, which let him finish in two days what would normally take months.

Nishikawa-san: Deploying Node-RED to Code Engine with IBM Bob and the IaC Spec Kit

Overview of Infrastructure as Code and Terraform Basics

Kohei Nishikawa is an IBM Champion of 10 years and an associate professor who teaches IaC at university, in addition to running corporate Terraform workshops for AWS and Sakura Cloud.
IaC manages infrastructure as code, offering benefits like lower costs, change history tracking, team sharing, and better reproducibility — often more efficient than clicking through a browser GUI.
He noted that Terraform and Ansible, two major IaC tools, are both now under the IBM group (via Red Hat), which he finds interesting given how central these tools are.
The basic Terraform workflow is: terraform init → terraform plan (preview) → terraform apply (deploy) → terraform destroy (remove).
For this session, he installed Terraform and the IBM Cloud CLI inside WSL (Ubuntu) on Windows, and launched the IBM Bob IDE from WSL.
To control IBM Cloud from IBM Bob, an IBM Cloud API key and resource group name must be prepared in advance; he walked through creating an API key from the IAM console.

Implementation and Demo Using IBM’s IaC Spec Kit

IBM’s publicly available “IaC Spec Kit” on GitHub is a template kit for IaC, and he confirmed it supports several AI assistants, including IBM Bob, before deciding to use it.
Some samples in the IaC Spec Kit (such as WordPress) include billable resources like Database for MySQL, so running them without reading the documentation carefully can result in unexpected charges (which happened to him).
His workflow was: ispec init (define the spec) → ispec plan (detailed technical design) → working with IBM Bob to build the configuration files, with auto-approval turned off so he could check each step.
He stressed that turning off auto-approval and confirming each action is important, since IBM Bob can sometimes try to take actions on its own beyond what was asked.
The finished configuration successfully runs Node-RED on Code Engine, and he showed that things like container memory allocation and output definitions need to be set carefully.
Going forward, he’s testing a hybrid approach: writing the implementation plan first with a Granite model (4.1, etc.), then feeding it into IBM Bob’s IaC Spec Kit.

Discussion: Bob Coin Pricing, Tool Comparisons, and Notes on AI Agent Caution

Participants discussed whether the 40 Bob coins given during the free trial carry over after the trial ends; checking Nishikawa-san’s account screen showed “90% of monthly budget remaining, resets June 14,” confirming the anniversary-based reset (one month from the contract start date).
When asked directly, IBM Bob estimated that a small app (a Node.js backend plus a simple frontend) would cost around 2–2.5 coins, meaning the 40 trial coins (roughly 1,000–1,500 yen worth) are enough for solid development work.
One key difference raised was that Claude Code’s usage limit resets automatically after some time even once you hit it, while IBM Bob’s coin-based system requires purchasing more once you run out.
On tool choice, the consensus was: use Claude Code for end-to-end design-to-coding work, and GitHub Copilot for smaller code reviews and edits; IBM Bob was seen as closer to Claude Code’s all-in-one style.
When letting AI coding agents handle infrastructure work (like Terraform), risks include automatically creating billable resources, adding unintended files, or running unsafe database queries — so it’s important to disable auto-approval and confirm each step.
It remains unclear, officially, how IBM Bob chooses between models like Granite internally, and participants speculated it may select among several models as sub-agents.

Closing: Next Event and Summary

Today’s three talks each offered a different angle — first impressions, app development, and infrastructure work — giving a well-rounded picture from getting started to practical use of IBM Bob.
The next JICUG event will be held on June 30, continuing the monthly schedule.
The next theme will focus on applying AI to infrastructure, including work with IBM services such as Code Engine and Db2 on IBM Cloud.
All participants came away confirming that IBM Bob is a practical, capable tool that holds up well against Claude Code as an end-to-end development experience.
A shared takeaway was that using AI coding agents safely requires enough systems and infrastructure knowledge to catch mistakes, along with preparing specs ahead of time and checking each step carefully.