IBM Bob Workshop for IBMers¶

Accelerate Your Work with Agentic AI¶

Workshop Overview¶

This hands-on workshop demonstrates how IBM Bob, an agentic AI assistant, can transform your daily work at IBM. Through practical exercises, you'll experience Bob's capabilities in code development, documentation, analysis, automation, and more. Learn how to leverage Bob to increase productivity, improve code quality, and accelerate project delivery.

Duration: 75 minutes

Target Audience: IBM employees (developers, architects, consultants, technical leaders)

Prerequisites: Basic familiarity with software development concepts

Materials Needed: Laptop with Bob access, VS Code with Bob extension

What is Agentic AI?¶

Traditional AI vs. Agentic AI¶

Traditional AI Assistants:

Answer questions and provide information
Generate code snippets on request
Offer suggestions and recommendations
Passive interaction model

Agentic AI (IBM Bob):

Autonomous action: Takes initiative to complete tasks
Tool usage: Reads, writes, and modifies files independently
Multi-step reasoning: Breaks complex tasks into executable steps
Context awareness: Understands project structure and relationships
Iterative refinement: Adapts based on results and feedback

Key Differentiator: Bob doesn't just suggest—Bob executes, creating tangible deliverables.

Bob's Professional Workflow: Understand → Plan → Constrain → Change → Verify¶

This workshop is structured around Bob's systematic approach to problem-solving, mirroring professional software engineering practices. Each part demonstrates a phase of this methodology along with the optimal Bob mode for that phase.

The Five-Phase Methodology¶

Phase	Focus	Best Mode	Purpose
Understand	Analysis & Context	❓ Ask Mode	Gather information, analyze existing systems
Plan	Design & Strategy	📝 Plan Mode	Create roadmaps, design architecture
Constrain	Scope & Boundaries	📝 Plan Mode	Define requirements, set standards
Change	Implementation	💻 Code / 🛠️ Advanced	Build, modify, refactor code
Verify	Testing & Review	❓ Ask Mode	Validate quality, test functionality

Workshop Structure¶

Part 1: Code Development & Refactoring (20 minutes)¶

Workflow Phase: CHANGE - Implementation Recommended Mode: 💻 Code Mode

This section demonstrates Bob's systematic implementation capabilities. Notice how Bob follows the CHANGE phase: creating structured, production-ready code based on clear requirements.

Exercise 1.1: Rapid Prototyping - REST API Development¶

Objective: Experience Bob's ability to scaffold complete, production-ready code

Scenario: You need to quickly prototype a microservice for a client demo.

Workflow Context: This exercise demonstrates the CHANGE phase where Bob implements a complete solution. In a real project, you would first UNDERSTAND requirements and PLAN the architecture before this step.

Task (Code Mode):

Bob, create a Node.js REST API for a product catalog service with:
- Express.js framework
- CRUD endpoints for products (GET, POST, PUT, DELETE)
- Input validation using express-validator
- Error handling middleware
- OpenAPI/Swagger documentation
- Environment configuration
- Proper project structure with separate routes, controllers, and models
- README with setup instructions

Save it in a folder called "product-catalog-api"

What to observe: - Bob creates multiple files with proper separation of concerns - Implements industry best practices (error handling, validation, documentation) - Generates complete, runnable code - Includes documentation and setup instructions - Time saved: ~2-3 hours of manual coding

Discussion Points: - How does this accelerate proof-of-concept development? - What would you need to add for production readiness? - How does Bob's code quality compare to manual development?

Exercise 1.2: Legacy Code Modernization¶

Objective: See Bob analyze and refactor existing code

Workflow Context: This exercise combines UNDERSTAND (Bob analyzes existing code) and CHANGE (Bob refactors incrementally). Notice how Bob first reads and understands the codebase before making modifications.

Task (Code Mode):

Bob, please analyze the product-catalog-api code you just created and:
1. Add TypeScript support with proper type definitions
2. Implement dependency injection pattern
3. Add unit tests using Jest
4. Add logging with Winston
5. Implement rate limiting middleware
6. Create a Docker configuration for containerization

Make these changes incrementally, explaining each improvement.

What to observe: - UNDERSTAND: Bob reads and understands existing code structure first - CHANGE: Makes surgical, targeted changes without breaking functionality - Adds enterprise-grade features systematically - Maintains code consistency and style - Explains architectural decisions

Workflow Principle: Bob doesn't blindly modify code. He first understands the existing structure, then makes informed changes. This prevents breaking existing functionality.

Real-world application: - Modernizing legacy IBM client applications - Adding enterprise features to existing codebases - Preparing code for cloud migration - Implementing security and compliance requirements

Part 2: Documentation & Knowledge Management (15 minutes)¶

Workflow Phase: UNDERSTAND + VERIFY Recommended Mode: ❓ Ask Mode

This section demonstrates how Bob analyzes and documents existing systems (UNDERSTAND) and performs quality assessments (VERIFY). Documentation requires deep understanding of the codebase.

Exercise 2.1: Automated Documentation Generation¶

Objective: Transform code into comprehensive documentation

Workflow Context: This demonstrates the UNDERSTAND phase. Bob must thoroughly analyze the code to create accurate documentation. Good documentation proves Bob truly understands the system.

Task (Ask Mode):

Bob, create comprehensive technical documentation for the product-catalog-api:
1. Architecture overview with component diagram (ASCII art)
2. API reference with all endpoints, parameters, and responses
3. Setup and deployment guide
4. Security considerations and best practices
5. Troubleshooting guide
6. Contributing guidelines for team members

Save as "TECHNICAL_DOCUMENTATION.md"

What to observe: - UNDERSTAND: Bob analyzes code to extract accurate information - Creates structured, professional documentation - Includes practical examples and use cases - Follows documentation best practices - Time saved: ~4-6 hours of manual documentation

Workflow Principle: Quality documentation requires deep understanding. Bob reads and analyzes the code systematically before documenting, ensuring accuracy.

IBM Use Case: - Client deliverable documentation - Internal knowledge base articles - Onboarding materials for new team members - Compliance and audit documentation

Exercise 2.2: Code Review & Analysis Report¶

Objective: Automated code quality assessment

Workflow Context: This demonstrates the VERIFY phase. Bob validates code quality, identifies issues, and ensures standards are met before deployment.

Task (Ask Mode):

Bob, perform a comprehensive code review of the product-catalog-api and create a report covering:
1. Code quality assessment (structure, readability, maintainability)
2. Security vulnerabilities and concerns
3. Performance optimization opportunities
4. Best practices compliance
5. Suggested improvements with priority levels
6. Technical debt identification

Save as "CODE_REVIEW_REPORT.md"

What to observe: - VERIFY: Bob systematically validates code quality and standards - Identifies issues a human reviewer would catch - Provides actionable recommendations - Prioritizes findings by severity - Explains the reasoning behind each suggestion

Workflow Principle: Verification catches issues before production. Bob's systematic review ensures code meets quality standards and requirements.

IBM Use Case: - Pre-deployment code reviews - Technical debt assessment - Client code audits - Compliance verification

Part 3: Data Analysis & Automation (15 minutes)¶

Workflow Phase: UNDERSTAND + CHANGE Recommended Mode: 💻 Code Mode

This section shows Bob analyzing data (UNDERSTAND) and creating automation tools (CHANGE). Bob extracts insights from existing data and builds tools to automate repetitive tasks.

Exercise 3.1: Log Analysis & Insights¶

Objective: Extract insights from application logs

Workflow Context: This combines UNDERSTAND (analyzing log patterns) and CHANGE (building the analysis tool). Bob must understand log structures before creating effective analysis.

Task (Code Mode):

Bob, create a log analysis tool that:
1. Reads application log files
2. Identifies error patterns and frequency
3. Extracts performance metrics (response times, throughput)
4. Detects anomalies and unusual patterns
5. Generates a visual HTML dashboard with charts
6. Provides actionable recommendations

Create sample log data and demonstrate the analysis.
Save in "log-analyzer" folder.

What to observe: - UNDERSTAND: Bob analyzes log patterns and structures - CHANGE: Creates both the analyzer and sample data - Implements data processing logic - Generates visual representations - Provides business insights from technical data

Workflow Principle: Effective automation requires understanding the data first. Bob analyzes patterns before building tools.

IBM Use Case: - Client system monitoring - Incident analysis and root cause identification - Performance optimization - Proactive issue detection

Exercise 3.2: Test Data Generation¶

Objective: Automate test data creation

Workflow Context: This demonstrates CONSTRAIN (understanding test requirements and edge cases) and CHANGE (implementing the generator). Bob considers constraints like data validity and edge cases.

Task (Code Mode):

Bob, create a test data generator for the product catalog API that:
1. Generates realistic product data (names, descriptions, prices, categories)
2. Creates various test scenarios (edge cases, boundary conditions)
3. Exports data in multiple formats (JSON, CSV, SQL)
4. Includes data validation rules
5. Supports configurable data volume
6. Provides seeding scripts for database initialization

Save in "test-data-generator" folder.

What to observe: - CONSTRAIN: Bob understands testing requirements and edge cases - CHANGE: Creates realistic, varied test data - Supports multiple output formats - Includes documentation and usage examples

Workflow Principle: Good test data requires understanding constraints and edge cases. Bob considers boundary conditions and validation rules.

IBM Use Case: - QA and testing automation - Demo environment setup - Performance testing data - Client UAT preparation

Part 4: Client-Facing Deliverables (15 minutes)¶

Workflow Phase: PLAN + CONSTRAIN Recommended Mode: 📝 Plan Mode

This section demonstrates strategic planning and constraint definition. Bob creates proposals and assessments that require understanding requirements, planning solutions, and defining constraints.

Exercise 4.1: Technical Proposal Generator¶

Objective: Create client-ready technical documentation

Workflow Context: This demonstrates PLAN (solution architecture and timeline) and CONSTRAIN (risk assessment and success metrics). Bob creates strategic documents that guide implementation.

Task (Plan Mode):

Bob, create a technical proposal document for the product catalog API as if presenting to a client:
1. Executive summary
2. Solution architecture with diagrams
3. Technology stack justification
4. Implementation timeline and phases
5. Risk assessment and mitigation strategies
6. Cost-benefit analysis framework
7. Success metrics and KPIs
8. Next steps and recommendations

Format as a professional markdown document with proper structure.
Save as "TECHNICAL_PROPOSAL.md"

What to observe: - PLAN: Bob designs solution architecture and implementation roadmap - CONSTRAIN: Defines success metrics and risk mitigation - Creates business-focused technical content - Balances technical depth with accessibility - Includes strategic considerations

Workflow Principle: Good proposals require planning before implementation. Bob thinks through architecture, risks, and success criteria upfront.

IBM Use Case: - Client proposals and RFP responses - Architecture decision records - Executive briefings - Stakeholder communications

Exercise 4.2: Migration Assessment Tool¶

Objective: Analyze and plan system migrations

Workflow Context: This combines UNDERSTAND (analyzing current state), PLAN (migration roadmap), and CONSTRAIN (identifying blockers and requirements). Bob performs comprehensive assessment before recommending changes.

Task (Plan Mode or Code Mode for tool creation):

Bob, create a cloud migration assessment tool that:
1. Analyzes a codebase for cloud-readiness
2. Identifies dependencies and external integrations
3. Flags potential migration blockers
4. Estimates migration complexity and effort
5. Generates a migration roadmap with phases
6. Provides cost estimation framework
7. Creates a risk matrix

Include a sample analysis of the product-catalog-api.
Save in "migration-assessment" folder.

What to observe: - UNDERSTAND: Bob analyzes current codebase and dependencies - PLAN: Creates phased migration roadmap - CONSTRAIN: Identifies blockers and estimates complexity - Performs multi-dimensional analysis - Provides quantitative and qualitative assessments

Workflow Principle: Migration requires thorough understanding and planning. Bob assesses current state, plans the journey, and identifies constraints before execution.

IBM Use Case: - Cloud migration projects - Modernization assessments - Client consulting engagements - Technical due diligence

Part 5: Advanced Scenarios & Integration (10 minutes)¶

Workflow Phase: CHANGE + VERIFY Recommended Mode: 💻 Code Mode or 🛠️ Advanced Mode

This section demonstrates implementing automation (CHANGE) with built-in verification (VERIFY). CI/CD pipelines embody the complete workflow: they understand code, plan builds, enforce constraints, make changes, and verify results.

Exercise 5.1: CI/CD Pipeline Configuration¶

Objective: Automate deployment workflows

Workflow Context: This demonstrates CHANGE (implementing pipeline) and VERIFY (automated testing and quality gates). The pipeline itself enforces the workflow methodology automatically.

Task (Code Mode):

Bob, create a complete CI/CD pipeline configuration for the product-catalog-api:
1. GitHub Actions workflow (or Jenkins pipeline)
2. Multi-stage build process (lint, test, build, deploy)
3. Environment-specific configurations (dev, staging, prod)
4. Automated testing integration
5. Security scanning (dependency check, SAST)
6. Container image building and pushing
7. Deployment to Kubernetes
8. Rollback procedures

Include all necessary configuration files and documentation.

What to observe: - CHANGE: Bob implements comprehensive CI/CD automation - VERIFY: Includes automated testing, security scanning, and quality gates - CONSTRAIN: Enforces standards through pipeline gates - Creates production-ready DevOps configurations - Follows industry best practices

Workflow Principle: CI/CD pipelines automate the workflow. They understand code changes, plan builds, enforce constraints (quality gates), make changes (deploy), and verify results (tests).

IBM Use Case: - Client DevOps implementations - Internal project automation - Standardized deployment processes - Compliance and security automation

The Complete Workflow in Practice¶

How the Five Phases Work Together¶

Throughout this workshop, you've seen Bob's systematic approach:

UNDERSTAND (Part 2): Bob analyzes code, reads documentation, and gathers context before acting
PLAN (Part 4): Bob designs solutions, creates roadmaps, and thinks through architecture
CONSTRAIN (Part 3): Bob considers requirements, edge cases, and quality standards
CHANGE (Part 1): Bob implements systematically, following plans and respecting constraints
VERIFY (Part 2, Part 5): Bob validates quality, tests functionality, and ensures requirements are met

Mode Selection Guide¶

Phase	Best Mode	When to Use	Example
UNDERSTAND	❓ Ask Mode	Analyzing code, gathering requirements	"Bob, analyze this codebase and explain the architecture"
PLAN	📝 Plan Mode	Designing solutions, creating roadmaps	"Bob, create a migration plan for this application"
CONSTRAIN	📝 Plan Mode	Defining requirements, setting boundaries	"Bob, what constraints should we consider for this feature?"
CHANGE	💻 Code Mode	Standard implementation	"Bob, implement this feature following our plan"
CHANGE	🛠️ Advanced Mode	Implementation needing MCP/browser	"Bob, implement and test this in the browser"
VERIFY	❓ Ask Mode	Code review, quality assessment	"Bob, review this code for security issues"

Why This Methodology Matters¶

Without the workflow: - ❌ Misaligned solutions that don't meet requirements - ❌ Rework due to missed constraints - ❌ Quality issues discovered late - ❌ Scope creep and unclear boundaries

With the workflow: - ✅ Solutions aligned with actual needs - ✅ Constraints identified upfront - ✅ Quality built in from the start - ✅ Clear scope and boundaries - ✅ Faster delivery with fewer issues

Key Takeaways for IBMers¶

1. Productivity Multiplier¶

Reduce development time by 40-60% for common tasks
Eliminate repetitive coding and documentation work
Focus on high-value architecture and design decisions
Accelerate client deliverables

2. Quality & Consistency¶

Enforce coding standards automatically
Generate comprehensive documentation consistently
Implement best practices by default
Reduce human error in repetitive tasks

3. Knowledge Amplification¶

Access best practices across multiple technologies
Learn new frameworks and patterns through examples
Get instant code reviews and suggestions
Bridge knowledge gaps in unfamiliar domains

4. Client Value Delivery¶

Faster proof-of-concept development
Higher quality deliverables
More time for client interaction and requirements gathering
Ability to handle more complex projects

5. Competitive Advantage¶

Respond to RFPs faster with better proposals
Demonstrate capabilities through rapid prototyping
Deliver more value in the same timeframe
Differentiate IBM's technical capabilities

Bob's Core Capabilities Demonstrated¶

File Operations¶

✅ Create complete project structures
✅ Read and analyze existing code
✅ Make surgical edits to specific files
✅ Organize multi-file projects

Code Development¶

✅ Generate production-quality code
✅ Implement design patterns and best practices
✅ Add tests, documentation, and configurations
✅ Refactor and modernize legacy code

Analysis & Insights¶

✅ Code review and quality assessment
✅ Security vulnerability identification
✅ Performance optimization recommendations
✅ Technical debt analysis

Documentation¶

✅ API documentation generation
✅ Architecture diagrams and explanations
✅ User guides and tutorials
✅ Technical proposals and reports

Automation¶

✅ CI/CD pipeline configuration
✅ Test automation and data generation
✅ Deployment scripts and procedures
✅ Monitoring and alerting setup

Best Practices for Using Bob at IBM¶

Do's ✅¶

Be Specific and Contextual - Provide clear requirements and constraints - Mention IBM-specific standards or client requirements - Specify technology stack preferences - Include security and compliance considerations

Iterate and Refine - Start with core functionality, then enhance - Ask Bob to explain architectural decisions - Request alternatives for critical components - Validate and test Bob's outputs

Leverage Bob's Strengths - Use for rapid prototyping and scaffolding - Automate repetitive documentation tasks - Generate boilerplate and configuration files - Perform code analysis and reviews

Maintain Quality Standards - Review Bob's code before client delivery - Ensure compliance with IBM and client standards - Test thoroughly in appropriate environments - Add human judgment for critical decisions

Don'ts ❌¶

Don't Skip Review - Always review code before production deployment - Verify security implementations - Test edge cases and error handling - Validate against client requirements

Don't Expose Sensitive Information - Avoid including client-specific data in prompts - Don't share proprietary algorithms or IP - Be cautious with security configurations - Follow IBM's data handling policies

Don't Over-Rely - Use Bob as a tool, not a replacement for expertise - Apply critical thinking to Bob's suggestions - Maintain your technical skills and knowledge - Make architectural decisions with human judgment

Don't Forget Context - Consider the full project lifecycle - Think about maintenance and scalability - Account for team skills and preferences - Align with long-term technical strategy

Real-World IBM Use Cases¶

Consulting & Client Delivery¶

Rapid POC Development: Create working prototypes in hours instead of days
Technical Proposals: Generate comprehensive, professional proposals quickly
Code Modernization: Assess and refactor legacy client applications
Documentation: Create client-ready technical documentation

Internal Development¶

Microservices Development: Scaffold new services with best practices
API Development: Create consistent, well-documented APIs
Testing Automation: Generate test suites and test data
DevOps Automation: Configure CI/CD pipelines and deployment scripts

Architecture & Design¶

Architecture Documentation: Generate ADRs and design documents
Code Reviews: Automated quality and security assessments
Migration Planning: Assess cloud-readiness and create migration plans
Technical Debt Analysis: Identify and prioritize improvements

Knowledge Management¶

Onboarding Materials: Create comprehensive guides for new team members
Best Practices Documentation: Codify team standards and patterns
Troubleshooting Guides: Document common issues and solutions
Training Materials: Generate examples and tutorials

Integration with IBM Tools & Processes¶

IBM Cloud¶

Generate IBM Cloud deployment configurations
Create Cloud Foundry or Kubernetes manifests
Configure IBM Cloud services (Databases, Watson, etc.)
Implement IBM Cloud security best practices

IBM Watson¶

Scaffold Watson API integrations
Create Watson service wrappers and utilities
Generate Watson-powered application templates
Document Watson implementation patterns

IBM Security¶

Implement IBM security frameworks
Generate security compliance documentation
Create security testing scenarios
Configure security scanning tools

IBM DevOps¶

Configure IBM UrbanCode Deploy pipelines
Create Jenkins pipeline scripts
Generate deployment automation
Implement IBM DevOps best practices

Measuring Bob's Impact¶

Productivity Metrics¶

Time Saved: Track hours saved on development tasks
Velocity Increase: Measure sprint velocity improvements
Code Quality: Monitor defect rates and code review findings
Documentation Coverage: Assess documentation completeness

Business Metrics¶

Faster Time-to-Market: Reduce project delivery timelines
Client Satisfaction: Improve deliverable quality and timeliness
Resource Optimization: Handle more projects with same team size
Competitive Win Rate: Increase proposal success rates

Quality Metrics¶

Code Coverage: Improve test coverage percentages
Security Vulnerabilities: Reduce security findings
Technical Debt: Decrease technical debt accumulation
Standards Compliance: Increase adherence to coding standards

Advanced Tips & Tricks¶

Prompt Engineering for Better Results¶

Instead of:

Create an API

Try:

Create a Node.js REST API following IBM's microservices best practices with:
- Express.js framework
- OpenAPI 3.0 documentation
- JWT authentication
- Request validation
- Error handling middleware
- Structured logging
- Health check endpoints
- Prometheus metrics

Iterative Development Pattern¶

Start with structure: Ask Bob to create the project skeleton
Add core features: Implement main functionality
Enhance quality: Add tests, documentation, error handling
Optimize: Request performance improvements and refactoring
Secure: Add security features and compliance checks

Combining Bob with Other Tools¶

Use Bob to generate code, then review with SonarQube
Create Bob-generated tests, then run with your CI/CD pipeline
Generate documentation with Bob, then publish to Confluence
Use Bob for scaffolding, then customize for specific client needs

Q&A and Discussion¶

Common Questions¶

Q: Can Bob access our internal IBM systems or databases? A: No, Bob operates within your local development environment and doesn't access external systems unless explicitly configured with proper credentials.

Q: How do we ensure Bob-generated code meets IBM security standards? A: Always review Bob's code, run security scans, and apply your standard security review process. Bob can help implement security patterns, but human verification is essential.

Q: Can Bob work with proprietary IBM frameworks? A: Bob can work with any framework if provided with documentation or examples. You may need to guide Bob with specific IBM framework patterns.

Q: How do we handle client IP and confidentiality? A: Follow IBM's data handling policies. Don't include sensitive client information in prompts. Use Bob for generic implementations, then customize with client-specific details.

Q: What if Bob makes a mistake? A: Bob can make errors like any tool. Always review, test, and validate outputs. You can ask Bob to fix issues or try alternative approaches.

Next Steps¶

Immediate Actions¶

Start Small: Use Bob for a single task in your current project
Measure Impact: Track time saved and quality improvements
Share Knowledge: Teach teammates effective Bob usage patterns
Provide Feedback: Share your experiences to improve Bob

Building Expertise¶

Practice Prompt Engineering: Refine how you communicate with Bob
Explore Use Cases: Try Bob for different types of tasks
Create Templates: Develop reusable prompts for common IBM tasks
Document Patterns: Share successful Bob usage patterns with your team

Team Adoption¶

Pilot Projects: Use Bob on non-critical projects first
Establish Guidelines: Create team standards for Bob usage
Training Sessions: Conduct workshops for your team
Success Stories: Document and share wins with leadership

Resources & Support¶

Learning Resources¶

Bob documentation and user guides
IBM internal Bob community and forums
Example prompts and use case library
Video tutorials and demos

Getting Help¶

Bob support channels
IBM internal AI assistance team
Community best practices repository
Regular office hours and Q&A sessions

Staying Updated¶

Bob release notes and new features
IBM AI strategy updates
Industry best practices for agentic AI
Emerging use cases and patterns

Conclusion¶

IBM Bob represents a fundamental shift in how we approach software development and technical work. By leveraging agentic AI, IBMers can:

Deliver more value to clients in less time
Improve quality through consistent best practices
Accelerate innovation with rapid prototyping
Focus on strategy while Bob handles implementation
Differentiate IBM through enhanced technical capabilities

The key to success is viewing Bob as a powerful tool that augments—not replaces—human expertise. Your domain knowledge, client relationships, architectural vision, and strategic thinking remain irreplaceable. Bob simply makes you more effective at executing on those insights.

Start using Bob today and experience the future of software development! 🚀

Workshop Feedback¶

We'd love to hear about your experience: - What use cases were most valuable? - What additional scenarios would you like to explore? - How can we improve this workshop? - What challenges do you foresee in adopting Bob?

Workshop created for IBM Bob - Empowering IBMers with Agentic AI Version 1.0 - Designed for IBM employees Duration: 75 minutes Last Updated: 2026