The following is based on an AI-generated meeting transcript from Rimo.
Discussion Points
Opening & About JICUG
JICUG is a community run by users who work with IBM Cloud, and it’s currently being rebooted.
Anyone interested in IBM Cloud can join, regardless of contract plan or how they use it.
Joining the Connpass group makes you a JICUG member, able to post updates and speak at events.
IBM Champion Japan Forum 2026 Hackathon Overview
Venue: Amagi Homestead (an IBM facility)
Dates: August 3–4, 2026
35 IBM Champions from across Japan took part.
Theme: “An app that makes money from Izu’s tourism business”
Participants split into 6 teams for a super-fast hackathon: 80 minutes in the first half, 45 minutes in the second.
The presentation session ran for 80 minutes.
The brief called for ideas focused on actually making money, not just building an app.
Theme 1: Building the Frontend with IBM WatsonX Code Assistant (Bob IDE) (Seigo Tanaka)
Presenter: Seigo Tanaka, a freelance engineer (business name: 1ft Seabass).
App built: an Izu tourism support app (GPS-linked point collection, a coupon gacha, and AR navigation).
He used Bob IDE to generate an HTML scroll-style presentation deck, concluding that HTML worked better than PowerPoint for this.
He ran the demo on GitHub Codespaces and confirmed it worked reasonably well.
He logged the development process as he went in a Notes file inside a Docs folder, and combining that with the Git log let Bob review the process afterward.
He struggled with the sound system, the coin-point feature, and the AR camera implementation, but worked through them by discussing with Bob.
The main pain points were:
A Promise-reject error in the audio
Background music playing twice at once and blasting out at full volume
Lag in the AR camera stream
He found that keeping a regular log of the process made it easier to cope even when the design needed to be rebuilt.
He didn’t let Bob commit automatically — keeping that under human control let things move along smoothly.
Theme 2: Developing the Izu Stamp Rally (Ichiro Kano)
Presenter: Ichiro Kano, an IBM Champion who also works as a programming instructor, among other roles.
App built: Izu Stamp Rally, a web app where visitors collect QR codes from tourist spots to stamp their passport and compete on a ranking.
For brainstorming, the team churned out a large number of ideas on Post-its and left the sorting and organizing entirely to AI.
The neighboring team fed a photo of their whiteboard straight into AI, skipping the hassle of typing everything in by hand.
Kano-san told Bob, “Ask us if anything’s unclear,” which let it surface missing requirements on its own.
Bob asked questions about things like how to join the game, the authentication method, and the tech stack, and the spec was settled by having humans choose from its options.
Tech stack: Node.js, SQLite, WebSocket, QR codes, containers (Docker)
He specified Bootstrap CSS to auto-generate the website (only the images were made with another tool).
Event attendees scanned the QR codes with their phones, and the stamp rally was demoed live in real time.
Recommended development approach:
Don’t: build something quick and improve it later (this leads to lots of bugs, growing complexity, and rework)
Do: nail down the requirements and spec first, then generate the app (fewer bugs, and it comes together all at once)
Theme 3: Developing Izu Explorer (Kohei Nishikawa)
Presenter: Kohei Nishikawa, a university faculty member who also develops systems for hospitals, schools, and boards of education.
He was on the same team as Kano-san, and the two ended up developing two different apps in parallel.
App built: Izu Explorer, an all-in-one tourism app covering route suggestions, food-walk recommendations, souvenir recommendations, a stamp rally, and an admin screen.
He compiled the brainstorming notes into a Markdown file, handed it to Bob, and specified the architecture outright.
He had Bob generate a plan file (spec), checked it, fine-tuned it, and only then had it generate the code.
The plan file covered things like the API endpoints, screen layout, table design, and dependencies.
Because the spec was put together carefully, the resulting app worked with almost no errors.
He set Bob running overnight and left it, then finished up by debugging the next morning — an efficient workflow.
User state was handled with a combination of session IDs and SQLite (a full login feature was skipped due to time constraints).
The souvenir and food-walk recommendation features were built on the OpenAI (GPT-4o) API — in hindsight, he felt he should have used WatsonX instead.
He set things up so Docker Compose could bring up all the services at once.
Ask the Speakers & Casual Chat (Bonus Talk by Ichiro Kano)
Building on what he learned at the hackathon, Kano-san built his own “AI Employee” app that embeds AI directly inside the application.
What it does: an automated crypto trading app that runs unattended, 24/7.
Version 1.0: a human manually tuned the grid-trading logic.
Version 2.0: OpenAI periodically reviews the trade history and updates the parameters automatically.
Trading itself turned a small profit, but a major market crash wiped it out with a loss.
He was struck by how we’ve reached an era where an AI-embedded app can be built in about two days.
Next, he plans to build a second AI Employee using Bob.
He commented, “It’s fun to build an app you can seriously use for a hobby you love.”
Opening & Event Overview: Introducing JICUG
Seigo Tanaka opened the event as MC and introduced JICUG (the Japan IBM Cloud User Group). JICUG is a community run by Japanese users who work with IBM Cloud, and it’s currently being rebooted.
JICUG is open to anyone interested in IBM Cloud or using it for work, regardless of contract plan or how they use it.
Attendees were told that joining the connpass group makes them a JICUG member able to post updates, and that signing up for a lightning talk or a longer presentation is easy and welcome.
The heart of this event was sharing hackathon experiences from the IBM Champion Japan Forum 2026, held at Amagi Homestead, where 35 IBM Champions from across Japan took part.
The hackathon’s theme was “an app that makes money from Izu’s tourism business,” run as a super-fast workshop with 6 teams: 80 minutes in the first half, 45 minutes in the second.
The three speakers were Seigo Tanaka (frontend development with Bob IDE), Ichiro Kano (developing the Izu Stamp Rally), and Kohei Nishikawa (developing Izu Explorer).
The hackathon’s purpose wasn’t just building apps — it was also about building connections among participants, with brainstorming on Post-its and whiteboards, and bouncing ideas off IBM Bob.
Seigo Tanaka: Building a Frontend App with Bob IDE
Seigo Tanaka is a freelance engineer (business name: 1ft Seabass) who builds on a web-frontend base, bringing in generative AI, IoT, and XR.
At the hackathon, Tanaka-san built a support app for tourists visiting Izu, implementing a GPS-linked point-collection feature, a coupon gacha, and an AR compass/direction display.
He used IBM Bob to build an HTML scroll-style presentation deck, and reported that making the slides in HTML rather than PowerPoint worked well.
He ran the demo on GitHub Codespaces and confirmed that features like music playback, the AR camera, and GPS all worked reasonably well, despite the short build time.
He logged the development process as he went in a Notes file inside a Docs folder, and feeding that log plus the Git history into Bob let him reconstruct the process and the pain points later, in real time.
He worked through several technical problems together with Bob, including the sound system (background music playing twice, autoplay issues), lag in the AR camera stream, and the timing of coin-point updates.
By manually rotating the process log at regular intervals, he ended up with about 8 organized notes, and summed up that this gave him a history he could draw on even when the design needed to be rebuilt.
Ichiro Kano: Developing the Izu Stamp Rally App and Lessons in Using AI
Ichiro Kano works on server and global manufacturing technology and cloud management services, and on the side also runs an IT services business and teaches programming to kids.
At the hackathon, Kano-san’s team of six — mostly engineers — had a lively brainstorm around the “money-making app” theme, generating plenty of ideas, but they couldn’t keep up with sorting them all within the time limit.
Turning that time crunch to their advantage, the team fed the Post-it notes from the brainstorm straight into IBM Bob, letting AI take over the sorting and grouping step entirely.
Before starting development, they told Bob, “Ask us if anything’s unclear,” and settled the spec — the game-joining method, user authentication, and the tech stack (Node.js, SQLite, WebSocket, Docker) — through that back-and-forth.
They fed the finished program’s source code into Bob to auto-generate a website, and ended up with a Bootstrap-styled landing page in a short amount of time (the images were made with a different AI tool).
In the talk, Kano-san ran a live demo where attendees scanned QR codes to collect tourist-spot stamps and tried out the ranking and next-destination voting features firsthand.
He stressed how important it is to build a solid spec before developing the app, concluding that doing so sharply cuts down on later changes and fixes and lets you build a polished, low-bug app all at once.
Kohei Nishikawa: Developing Izu Explorer and Why the Plan File Mattered
Kohei Nishikawa is a university faculty member who also develops systems for hospitals and schools and reviews RFPs for boards of education, and previously worked at a group company within the Japan IBM group.
He ended up on the same team as Kano-san, and without really planning to, the two developed two different apps in parallel — Nishikawa-san’s was “Izu Explorer.”
He handed Bob a Markdown file with the brainstorming results, drawing on his own experience to lock in the architecture (Node.js 24, SQLite3, OpenStreetMap, Docker Compose) up front, and then had it produce a plan file (spec).
He handed the plan file to Bob around 7pm and let it run, and by the next morning the main features were working with almost no errors — debugging and testing in the morning made for an efficient workflow.
The app includes a tourist-spot stamp rally, a badge system, an admin screen, food-walk itinerary generation, and souvenir recommendations, with the OpenAI (GPT-4o) API powering the AI backend — he said he regretted not being able to use WatsonX instead.
He combined session IDs with a SQLite database to maintain user state without requiring login, finishing a practical app within the hackathon’s time limit.
He pointed to the care put into the plan file as the key to implementing it with almost no errors, and said he planned to write it up in a GitHub README and share the link later.
Seeing OpenAI’s API embedded inside Nishikawa-san’s app at the hackathon inspired Kano-san to build his own app with AI built in, which he introduced here.
He built an automated crypto trading app that runs unattended, 24/7, naming it “AI Employee.” In version 1.0, he manually tuned the logic himself (grid trading, and detecting up/down trends).
He ran it with 100,000 yen in seed capital over 3 months of automated trading, netting only a few yen of profit per trade — and then a major crypto crash left him with losses more than 10 times the profit he’d made.
Drawing on what he learned at the hackathon, he evolved it into version 2.0 over summer break, building in OpenAI (GPT-5.6 Luna) so the AI itself analyzes the trade history and rewrites its own parameters autonomously.
It’s designed to feed in prompts every 1, 3, 6, and 24 hours to review past trades, continuously optimizing the parameters while limiting how often it calls the API to keep costs down.
It integrates with two external APIs — the exchange and OpenAI — logging trade history in JSON so the AI keeps learning from past trends, giving it a self-evolving, agent-like architecture.
Even though it’s still running at a loss, he stressed his amazement that we’ve reached an era where an AI-embedded app can be built in about two days, and encouraged attendees to build an app they can seriously use for a hobby they love.
Closing: Scheduling the Next Event and Wrap-Up
With all three speakers done, Tanaka-san, as MC, closed the event by thanking the attendees, the speakers, and everyone supporting JICUG.
September 15 had been floated as a candidate date for the next event, but since Kano-san ended up with a business trip that day, the date needs to be adjusted and will be shared again later.
The group agreed that simply committing to holding an event in September mattered in its own right, with the exact date to be confirmed and announced later.
The shared takeaway from the whole event was a reconfirmation that building a solid spec (plan file) before letting AI develop from it is key to cutting bugs and boosting development efficiency.
It was shown that AI-driven development with IBM Bob can handle creative, open-ended work like building a prototype from scratch, and confidence in AI was widely shared among attendees.
The more advanced idea of embedding AI inside an app (turning it into an AI agent) was also laid out concretely through Kano-san’s and Nishikawa-san’s examples, drawing a lot of interest from attendees.
The date for the next event will be announced later via connpass and other channels, and the event wrapped up with a continued call for people to join the JICUG community and speak at future events.