|
IBM BOB V2.0 — FORTNIGHT 5 OF 6
Automate & Optimize
Skills · Subagents · Bobalytics · Git Automation
Updated for IBM Bob V2.0 (GA June 24, 2026). In V2, Skills run in Agent mode, subagents automate work in parallel, and Bobalytics measures agentic adoption and cost.
Turn repeatable work into reusable Skills, let subagents run automation in parallel, and use Bobalytics to prove value and optimize spend
Weeks 9–10 • Labs 9–11 • All Labs
|
|
Fortnight 5 Overview — now on IBM Bob V2.0
By the end of Fortnight 5 you will: package repeatable workflows as reusable Skills that your whole team can share, let V2 subagents and background tasks run automation in parallel, automate commit messages and pull requests, and read Bobalytics to prove business value and optimize your Bobcoin spend.
• Week 9: Skills — author reusable SKILL.md workflows and run them in Agent mode; subagents that use skills in parallel
• Week 10: Predictive editing, Git automation (commit messages + PRs), background tasks, and Bobalytics optimization
Time commitment: 3–4 hours per week
Prerequisites: Fortnights 1–4 complete on V2. Custom Modes and MCP from FN2 are helpful context for Skills.
Requires: IBM Bob V2.0 (GA June 24, 2026). If you are on v2.0.0, update to v2.0.2 or later. Every topic here is sourced from the live bob.ibm.com/docs.
|
|
What changed for this fortnight in V2
• Skills run in Agent mode. V1 required "Advanced mode" for skills. In V2 the five modes folded into three (Plan / Agent / Ask), and Skills run in Agent mode — or any custom mode that includes the skill tool group.
• Manage everything from Settings tabs. V2 adds dedicated Skills, Modes, and MCP Servers tabs in Settings — no manual JSON/YAML editing required.
• Automation runs in parallel. Subagents and background tasks let Bob run several automation streams at once; a 270k-token context window lets skills and workflows run further before compaction.
• Bobalytics is the optimization cockpit. V2 positions Bobalytics to drive agentic adoption, prove business value, and optimize cost — not just track spend.
|
|
FN 1 ✓
Get Started
|
FN 2 ✓
Build & Review
|
FN 3 ✓
Modernize
|
FN 4 ✓
Ship & Scale
|
FN 5 ← NOW
Automate
|
FN 6
V2 Power
|
Fortnight 5 — Learning Plan
|
WEEK 9 | Skills: Reusable Workflows for Your Team (V2)
Skills: Reusable Workflows for Your Team (V2)
|
|
Objective: Author reusable Skills that teach Bob your team's repeatable workflows once, then run them consistently in Agent mode across every conversation and every team member — now managed from the V2 Skills settings tab.
📖 Required Reading
• Skills — SKILL.md format, supporting files, locations, approval, best practices
• Modes (Agent / Plan / Ask) — the V2 three-mode model; Agent runs skills
• Custom modes — the skill tool group and the Modes settings tab
• Custom rules — behavioural guidelines vs reusable workflows
• Subagents — how subagents run focused work in parallel, each in its own mode
• Auto-approve — enabling "Always allow skills" for frictionless runs
🎬 Videos (youtube.com/@ibm-bob)
• Your Agentic AI Coding Partner — the V2 agentic model and reusable workflows
• IBM Bob Modes Demo — creating and managing modes in the V2 Settings tabs
🔑 Key Concept: Skills vs Modes vs Rules (V2)
|
• Skill = a reusable recipe (SKILL.md) that teaches Bob a specific workflow. Runs in Agent mode (or any mode with the skill group).
• Custom Mode = a specialised persona with defined tool groups (read, edit, command, browser, mcp, skill) and a role.
• Custom Rule = a behavioural guideline that applies across all interactions automatically.
Rule of thumb: if it's a repeatable multi-step task, make a Skill. If it's a persona / tool-group set, make a Mode. If it's an always-on guideline, make a Rule.
|
⚡ V2 Angle: Skills + Subagents
|
In V2, Bob can spawn subagents that each run in a focused mode with their own clean context. A subagent can invoke a skill to do a self-contained job — for example, one subagent running your security-review skill while another documents an API — and only the summaries return to your main thread. This is how "automate" scales in V2: reusable Skills executed in parallel by subagents.
|
🔬 Lab This Week
• Lab 9: Build a Skill — author a security-review SKILL.md with supporting files, then run it in Agent mode and manage it from the Skills settings tab (Section: Labs)
✅ Week 9 Checklist
□ Confirmed you are on IBM Bob V2.0 (v2.0.2 or later)
□ Created .bob/skills/ directory in your project root
□ Authored a SKILL.md with valid YAML front matter (name + description)
□ Added at least one supporting file (checklist or template)
□ Activated the skill in Agent mode and confirmed it ran
□ Viewed the skill in the Skills tab in Settings
□ Understood project-level (.bob/skills/) vs global (~/.bob/skills/) scope
|
|
WEEK 10 | Predictive Editing, Git Automation & Bobalytics (V2)
Predictive Editing, Git Automation & Bobalytics (V2)
|
|
Objective: Use Next Edit and Code Actions for predictive in-editor changes, automate commit messages and pull requests, run background tasks in parallel, and read Bobalytics to prove value and optimize cost.
📖 Required Reading
• Next Edit — predictive next-change suggestions as you work
• Code actions — quick-fix and refactor actions in the editor gutter
• Commit messages — auto-generate conventional commit messages
• Pull requests — generate PR titles and descriptions from your changes
• Enhance prompt — let Bob rewrite your prompt for better results
• Bobalytics — Bob Factor, spend, adoption and usage patterns (Enterprise)
• Rollback — restore precise states while automating (replaces V1 checkpoints)
🎬 Videos
• From Observability to Action — measuring and acting on usage data
• Deploy with Confidence: DevOps Plays — Git workflow automation
⚡ V2 Angle: Background Tasks & the Message Queue
|
• V2 runs multiple tasks in the background, each with its own thread and context — kick off an automation and keep working while it runs.
• You can redirect a running agent without cancelling it: new messages join a queue, you drag to reorder, and Bob works through them as it finishes each step.
• Rollback (not git-based checkpoints) lets you undo an automated change precisely — per task, per turn, or per tool call.
|
📊 Bobalytics: What to Measure in V2
|
Optimization cockpit
• Bob Factor — the percentage of Bob-created code, docs, and plans that were actually committed to your repositories. Your headline impact metric.
• Total spend & spend over time — Bobcoin consumption vs the previous period. Spot spikes, plan budget, optimize cost.
• Agentic adoption — team activity and daily active users; find who needs enablement to reach agentic maturity.
• Programming languages & modes — where Bob adds the most value and which of the three modes are underused.
Note: Bobalytics is an Enterprise-plan feature. Access it from Admin → Bobalytics at bob.ibm.com. Team usage data is available to all Enterprise users; admin access is not required for it.
|
🔬 Labs This Week
• Lab 10: Git Workflow Automation — auto-generate commit messages and a pull request, using Next Edit and Code Actions, with a background task running alongside
• Lab 11: Measure & Optimize with Bobalytics — read your Bob Factor, spend, and mode usage, then set optimization goals
|
All labs use github.com/IBM/bob-demo and your own projects, on IBM Bob V2.0. Clone once if needed: git clone https://github.com/IBM/bob-demo.git
Lab 9 — Build a Reusable Skill (V2)
|
Overview
Time: ~55 min | Difficulty: Intermediate | Mode(s): Agent
Goal: Author a SKILL.md security-review workflow with supporting files, then activate it in Agent mode and manage it from the V2 Skills settings tab.
|
Part A — Create the Skill
1. Create the skill directory. In your project root (use the express-todo-api from bob-demo, or your own repo):
|
mkdir -p .bob/skills/security-review
|
2. Author SKILL.md. Create .bob/skills/security-review/SKILL.md with this exact content (official docs format):
|
---
name: security-review
description: Review code for security vulnerabilities and best practices
---
Perform a security-focused code review:
<Steps>
<Step>
Check for common vulnerabilities:
- SQL injection risks
- XSS vulnerabilities
- Authentication/authorization issues
- Sensitive data exposure
</Step>
<Step>
Review security best practices:
- Input validation
- Output encoding
- Secure configuration
- Error handling
</Step>
<Step>
Provide findings with:
- Severity level (Critical, High, Medium, Low)
- Location in code
- Recommended fix
- Reference to security standards
</Step>
</Steps>
Use the severity guide in `severity-levels.md` for classification.
|
3. Add a supporting file. Create .bob/skills/security-review/severity-levels.md:
|
# Severity Levels
- **Critical**: Remote code execution, auth bypass, data breach risk
- **High**: Injection flaws, broken access control
- **Medium**: Information disclosure, weak configuration
- **Low**: Best-practice deviations, defense-in-depth gaps
|
Part B — Run the Skill in Agent Mode (V2)
4. Switch to Agent mode. In V2, Skills run in Agent mode (which absorbed the old Advanced mode). Select Agent from the mode dropdown or type /agent.
5. Trigger the skill. Ask Bob something that matches the skill description:
|
@/src Run a security review of this source directory.
|
Bob detects the matching skill and asks for approval to activate it (unless you enabled "Always allow skills"). Approve it.
6. Verify the workflow. Confirm Bob followed the 3-step structure and used the severity levels from your supporting file.
7. Manage it in Settings. Open Bob Settings and select the Skills tab. Confirm your security-review skill is listed and available in the workspace — a new V2 management surface, no file digging required.
8. Optional — parallelise with a subagent. Ask Bob to spawn a subagent that runs the security-review skill on one folder while the main agent documents another. Approve the spawn and review the returned summary. This is V2 automation at work.
9. Optional — make it global. Move the skill to ~/.bob/skills/security-review/ to use it across all projects. Project-level skills take precedence over global ones with the same name.
|
✅ Lab 9 Success Criteria
• SKILL.md created with valid YAML front matter (name + description)
• Supporting severity-levels.md present and read by Bob during the run
• Skill activated in Agent mode and followed the defined 3-step workflow
• Skill visible and manageable in the Skills tab in Settings
• You can explain when to use a Skill vs a Custom Mode vs a Custom Rule in V2
|
Lab 10 — Git Workflow Automation (V2)
|
Overview
Time: ~45 min | Difficulty: Intermediate | Mode(s): Agent
Goal: Automate commit messages and pull requests, using Next Edit and Code Actions, with a background task running alongside.
|
Steps
10. Make a change with Code Actions. Open a source file. Look for the lightbulb / Code Action indicator in the gutter on a line with a warning. Apply a Bob quick-fix or refactor action.
11. Accept a Next Edit suggestion. As you keep editing, Bob predicts your next change. When the Next Edit suggestion appears, accept it if correct. This chains related edits without prompting.
12. Kick off a background task. Start a separate task — e.g. "document all endpoints in @/src" — and let it run in the background while you continue with the Git steps. In V2 each task keeps its own thread and context.
13. Stage your changes.
14. Auto-generate a commit message. In the Source Control panel, click the Bob commit-message (sparkle) icon next to the message box. Bob reads your staged diff and writes a conventional commit message. Review, edit if needed, then commit.
15. Generate a pull request. After pushing your branch, use Bob's Pull Requests feature to generate a PR title and description from your commits. Review the generated summary before creating the PR.
16. Try Enhance Prompt. In the chat, type a deliberately vague request like "fix the api", then click Enhance Prompt. Compare Bob's rewritten, specific prompt to your original.
17. Undo precisely with Rollback. If any automated change went too far, open Rollback and restore to a specific turn or tool call — no git checkpoint needed in V2.
|
✅ Lab 10 Success Criteria
• Applied at least one Code Action and accepted one Next Edit suggestion
• Ran a background task alongside your Git work
• Auto-generated a conventional commit message from staged changes
• Generated a PR title and description with Bob
• Used Enhance Prompt and compared the rewritten prompt to your original
|
Lab 11 — Measure & Optimize with Bobalytics (V2)
|
Overview
Time: ~40 min | Difficulty: Intermediate — Enterprise plan | Mode(s): Web portal (Admin → Bobalytics)
Goal: Read your Bob Factor, spend, and mode usage; set concrete optimization goals from real data.
|
|
⚠ Plan Requirement
Bobalytics is an Enterprise-plan feature. If you are on a non-Enterprise plan, read the Bobalytics documentation and complete this lab conceptually using the metric definitions, or ask your IBM Bob admin for a guided view.
|
Steps
18. Open Bobalytics. Go to bob.ibm.com and log in. Click Admin, then select the Bobalytics tab.
19. Read your Bob Factor. Find the Bob Factor — the percentage of Bob-created code, docs, and plans committed to your repositories. Record it.
20. Review spend over time. Look at Total Spend and the Spend Over Time chart. Identify any Bobcoin spikes and note what work caused them — subagents and background tasks can change your spend profile in V2.
21. Analyse mode usage. Check the Bob Modes breakdown. With V2's three modes, an unused Plan mode often signals rushing straight into Agent mode — a quality risk.
22. Review language and repository contribution. See which languages and repositories benefit most. Identify a repo with low Bob Factor that could benefit from more agentic adoption.
23. Set one optimization goal. Write a concrete goal from a real insight. Examples: "Raise Plan-mode usage to cut rework" or "Increase Bob Factor in billing-service from X% to Y% next fortnight" or "Cut Bobcoin spend per feature by routing exploration to subagents."
|
✅ Lab 11 Success Criteria
• Recorded your Bob Factor and total spend for the period
• Identified at least one spend spike and its cause
• Noted your most-used and least-used of the three V2 modes
• Wrote one concrete, measurable optimization goal from a Bobalytics insight
|
V1 → V2 Changes That Affect This Fortnight
|
Topic
|
V1
|
V2
|
|
Mode to run Skills
|
Advanced mode
|
Agent mode (or any mode with the skill group)
|
|
Managing skills
|
Files only
|
Skills tab in Settings + files
|
|
Managing modes / MCP
|
Manual YAML / JSON
|
Modes tab and MCP Servers tab in Settings
|
|
Automation in parallel
|
One tool at a time
|
Subagents + parallel tool calls + background tasks
|
|
Undo an automated change
|
Git-based checkpoints
|
Rollback — per task / turn / tool call, no git
|
|
Context for long skills
|
200k tokens
|
270k tokens
|
|
Bobalytics framing
|
Track usage & spend
|
Drive adoption, prove value, optimize cost
|
Skill Templates (from official docs)
Ready-to-adapt SKILL.md descriptions straight from the documentation:
|
Skill name
|
Description (use in YAML front matter)
|
|
security-review
|
Review code for security vulnerabilities and best practices
|
|
api-docs
|
Generate comprehensive API documentation
|
|
feature-implementation
|
Implement new features following team standards
|
|
code-review
|
Review code for bugs, security issues, and best practices
|
|
api-documentation
|
Generate API documentation following OpenAPI standards
|
YouTube Videos (youtube.com/@ibm-bob)
|
Title
|
Best paired with
|
|
Your Agentic AI Coding Partner
|
Week 9 (V2 agentic model, Skills)
|
|
IBM Bob Modes Demo
|
Lab 9 (Agent mode + Settings tabs)
|
|
From Observability to Action
|
Lab 11 (Bobalytics)
|
|
Deploy with Confidence: DevOps Plays
|
Lab 10 (Git automation)
|
|
Code Review Simplified: Shift-Left
|
Lab 9 (security-review skill)
|
Skills vs Modes vs Rules vs MCP — Decision Guide (V2)
|
You want to...
|
Use
|
Where it lives
|
|
Run a repeatable multi-step workflow on demand
|
Skill
|
.bob/skills/<name>/SKILL.md (Skills tab)
|
|
Change Bob's persona and tool groups
|
Custom Mode
|
.bob/custom_modes.yaml (Modes tab)
|
|
Apply an always-on behavioural guideline
|
Custom Rule
|
.bob/rules/<name>.md
|
|
Give Bob access to an external tool/service
|
MCP Server
|
.bob/mcp.json (MCP Servers tab)
|
|
Run automation streams in parallel
|
Subagents
|
Spawned by Agent, approved per spawn
|
|
Share any of the above with your team
|
Version control
|
commit the .bob/ directory
|
|
Automate & Optimize — the V2 way
Reusable Skills in Agent mode, subagents running automation in parallel, and Bobalytics proving value and optimizing spend.
Next up: Fortnight 6 — V2 Power: subagents, background tasks, rollback, and Workflows in depth.
Keep going: bob.ibm.com/docs | youtube.com/@ibm-bob
IBM Bob Customer Success Team
|
#community-stories1