blue/.blue/docs/spikes/2026-01-26T1000Z-claudebot-functionality-transfer-opportunities.done.md

Spike: ClaudeBot Functionality Transfer Opportunities

Status	Complete
Date	2026-01-26
Time Box	1 hour

---

Question

What user-facing functionality from ClaudeBot could add value to Blue's developer workflow?

---

Source

github.com/ClaudeBot/ClaudeBot — Hubot IRC bot with 24 external plugins and 5 custom scripts. The ClaudeBot org maintains 30 repos including custom Hubot plugins.

ClaudeBot's Full Feature Map

Feature	Source	What It Does
Reminders	hubot-remind-advanced	Natural language reminders with conversational flow
Link tracking	hubot-links	Auto-captures shared URLs, recall recent links
Search	hubot-search	Google/Bing search from chat
Stack Overflow	custom script	Search SO questions inline
CDN lookup	custom script	Find library CDN URLs
YouTube	hubot-youtube + youtube-info + youtube-tracker	Video search, metadata, URL detection
Google Images	hubot-google-images	Image search
Translation	hubot-google-translate	Translate text between languages
Wikipedia	hubot-wikipedia	Wiki article lookup
Twitch/Steam	hubot-twitch, hubot-steam-webapi	Streaming and game info
URL shortening	hubot-googl	Shorten URLs
Pastebin	hubot-paste	Paste long text externally
Long text handling	hubot-longtext	Auto-paste long responses, return link
Man pages	hubot-manpages	Unix manual lookups
Email	hubot-mail	Send email from chat
Auth/roles	hubot-auth	Role-based command access
Diagnostics	hubot-diagnostics	Self-inspection and health
Help	hubot-help	Auto-aggregated command help
Brain persistence	hubot-redis-brain	Key-value persistence across sessions
Web archiving	hubot-archive-today	Archive web pages
Admin tools	custom script	Brain wipe, uptime, restricted commands
ASCII faces	custom script	Random ASCII art (fun)

What Blue Already Covers

• Reminders: blue_reminder_create/list/snooze/clear — already implemented
• Search: blue_index_search — semantic index with FTS5
• Diagnostics/Health: blue_health_check — already implemented
• Help: blue_guide + status/next system — already implemented
• Persistence: SQLite — already implemented
• Auth concepts: Not yet, but noted in architecture spike

Functionality Worth Transferring

1. Session Resource Tracking

ClaudeBot analog: hubot-links (auto-captures URLs shared in chat)

Blue version: During a dev session (blue_session_start → blue_session_stop), auto-capture external resources referenced — URLs, file paths, Stack Overflow links, GitHub issues, documentation pages. At session end, generate a "resources used" summary attached to the session record.

Why it matters: Developers reference dozens of resources during a session. These references evaporate when the session ends. Capturing them creates a reusable knowledge trail — especially valuable when picking up work days later or handing off to another developer.

Implementation surface: Extend session tracking in blue-core. Add a blue_session_bookmark MCP tool for explicit captures. Consider passive capture via hook on Claude Code's WebFetch/WebSearch calls.

2. Cross-Session Bookmarks

ClaudeBot analog: hubot-links list/clear — persistent link storage with recall

Blue version: blue_bookmark_add <url> [tags] / blue_bookmark_list [tag|rfc|spike] / blue_bookmark_search <query>. Bookmarks are tagged and associated with Blue documents (RFCs, spikes). When you start working on RFC 0016, Blue surfaces bookmarks tagged to it.

Why it matters: Blue already has a semantic index for code files. But external resources (docs, articles, SO answers, design references) aren't tracked. Bookmarks bridge that gap — they're lightweight, explicit, and immediately useful.

Implementation surface: New document type or key-value entries in SQLite. 2-3 new MCP handlers. Tags link to existing Blue documents via relationships (ADR 0006).

3. Smart Output Management

ClaudeBot analog: hubot-longtext (auto-detects long responses, pastes externally, returns link)

Blue version: When Blue outputs a large document (RFC, dialogue, audit), detect the length and offer tiered delivery:

• Summary mode: Key points only (~10 lines)
• Section mode: Table of contents with expandable sections
• Full mode: Everything

Could also generate a temporary local file and return the path, keeping the Claude Code context clean.

Note

: The temp-file-and-return-path approach is the preferred direction here. Write the full document to a local file, return a short summary + the file path in the MCP response. The developer clicks the path to read more. Context stays lean, content stays accessible. Start with this before building tiered delivery modes.

Why it matters: Blue documents can be 100-300 lines. Dumping them into Claude Code's context consumes tokens and overwhelms the conversation. Smart truncation keeps the developer in flow while preserving access to the full content.

Implementation surface: Response middleware in blue-mcp handlers. Each document type defines its own summary format. File output via temp directory.

4. External Knowledge Lookup

ClaudeBot analog: Stack Overflow script, hubot-search, hubot-wikipedia, hubot-manpages

Blue version: blue_lookup <query> [--source so|docs|crates|npm] — search external knowledge sources from within Blue. Results get cached in the semantic index with a "lookup" relationship type, so repeated questions for the same topic hit local cache.

Why it matters: Claude Code already has WebSearch. The difference is that Blue would remember the lookups — linking them to the current RFC/spike, indexing the results, and surfacing them when you return to that work context. The lookup becomes part of the project's knowledge, not ephemeral chat history.

Implementation surface: Reqwest calls to public APIs (Stack Exchange, crates.io, docs.rs). Results stored in semantic index. Relationship links to active Blue documents. 1-2 MCP handlers.

5. Outbound Notifications

ClaudeBot analog: hubot-mail (send email from chat)

Blue version: When important state transitions happen, notify through external channels:

• RFC status changes (draft → dialogue → final) → webhook/email
• Spike time-box expires → desktop notification
• Dialogue converges → notify all participants
• Contract schema change in realm → notify dependent repos
• Audit findings → email summary

blue_notify_configure to set up channels (webhook URL, email, desktop). Events fire automatically on state transitions.

Why it matters: Blue currently only surfaces information when you ask for it (blue_status, blue_next). Developers context-switch. A spike time-box expiring while you're deep in another task goes unnoticed. Push notifications close the feedback loop.

Implementation surface: Notification dispatch in blue-core daemon. Hook into existing state transition logic. Webhook sender via reqwest. Desktop notifications via notify-rust crate. Configuration stored in .blue/config.yaml.

6. Document Format Transformation

ClaudeBot analog: hubot-archive-today (capture/transform web content), hubot-paste (reformat for external consumption)

Blue version: Transform between Blue document types and export to external formats:

• blue_transform spike → rfc — extract spike findings into an RFC problem statement
• blue_transform rfc → github-issue — export RFC as a GitHub issue
• blue_transform dialogue → summary — condense dialogue rounds into key decisions
• blue_transform audit → checklist — convert audit findings to actionable checklist

Why it matters: Blue documents follow structured formats. Transformations between them are mechanical but tedious. Automating the common paths (spike → RFC is the most frequent) saves real time and ensures nothing gets lost in translation.

Implementation surface: Template-based transformations in blue-core. LLM-assisted for summarization transforms. GitHub export via existing forge integration. 1 MCP handler with subcommands.

7. Natural Language Time Expressions

ClaudeBot analog: hubot-remind-advanced uses Chrono for "in 1 hour", "tomorrow at 3pm", "next Monday"

Blue version: Blue's existing reminders could accept natural language time: blue_reminder_create "follow up on RFC 0016" "after lunch" or "in 2 hours". Also applicable to spike time-boxes: blue_spike_create ... --time-box "until end of day".

Why it matters: Small ergonomic win. Current reminders likely expect structured time formats. Natural language is faster and more human.

Implementation surface: Chrono-english or similar Rust crate for natural language date parsing. Thin wrapper around existing time handling.

What Doesn't Transfer

• Image/video search (YouTube, Google Images) — not relevant to dev workflow
• Gaming integrations (Steam, Twitch) — entertainment, not development
• URL shortening — no need in a CLI context
• ASCII art — fun but not Blue's voice
• Translation — Claude Code handles this natively

Prioritized Recommendations

High Value, Low Effort

1. Smart output management — keeps context clean, improves every interaction
2. Natural language time expressions — small crate addition, immediate ergonomic win

High Value, Medium Effort

3. Session resource tracking — passive capture during sessions, knowledge retention
4. Cross-session bookmarks — explicit capture, document-linked, immediately useful
5. Document format transformation — spike → RFC path alone justifies this

High Value, Higher Effort

6. External knowledge lookup with caching — powerful but requires API integrations
7. Outbound notifications — push model, requires daemon + channel configuration

Outcome

ClaudeBot's feature set is mostly API aggregation for an IRC chat context. The transferable ideas aren't the specific integrations (YouTube, Steam) but the workflow patterns they represent:

• Passive capture (links → session resource tracking)
• Smart output (longtext → tiered document delivery)
• Persistent recall (links list → cross-session bookmarks)
• Push notifications (mail → outbound state change alerts)
• Format bridging (archive/paste → document transformation)
• Natural interfaces (remind → natural language time)

The top three for Blue: smart output management, session resource tracking, and document transformation. These address real friction points in Blue's current workflow.