One Workspace, Two Minds: Building a Shared AI System with GitHub Copilot and IBM Bob
One Workspace, Two Minds: Building
a Shared AI System with GitHub Copilot and IBM Bob
Today’s Coffee — First Sip
Freshly ground Starbucks Pike Place, coarse in a French press. Strong.
Steady. Reliable.
Like coffee, this approach is simple but effective—it doesn’t try to
impress; it just works. It’s the foundation. Every sip builds familiarity,
every cup builds consistency. This is how your AI workspace should feel:
predictable, dependable, and aligned with your team’s needs.
What This Is
Many teams use GitHub Copilot in Visual Studio Code and IBM Bob
separately. Each tool is powerful:
- Copilot excels at inline code
generation, scaffolding, rapid iteration, and lightweight refactoring.
- Bob excels at structured IBM i
analysis, enforcing enterprise standards, and validating designs against
system-wide context.
But when used independently, neither shares memory, context, or lessons
learned. Each starts from zero on every new prompt.
The solution: build a shared AI workspace.
A shared workspace becomes the environment that both tools read from,
write to, and evolve. It holds:
- Rules — coding standards, naming
conventions, error handling patterns
- Context — historical decisions, system
quirks, known behaviors
- Patterns — reusable solutions, common
pitfalls, best practices
- Analysis — documented investigations and
reasoning
- Decisions — what was done, why, and
lessons learned
This isn’t just organization. It’s alignment. Knowledge persists, outputs
are consistent, and your AI stops guessing.
Where This Idea Came From
This methodology was inspired by a conversation with Tim Rowe. The
insight was simple but transformative:
AI becomes exponentially more effective when it operates inside a well-defined
workspace with shared context, instead of reacting to isolated prompts.
This idea changes how we think about AI tooling. You stop chasing better
prompts and start designing better systems. You don’t just use AI—you create a
living environment for it.
Why It Matters
Without a shared workspace:
- Copilot guesses locally, often
inconsistently
- Bob analyzes in isolation
- Standards drift
- Decisions get scattered across
Slack, Jira, and emails
With a shared workspace:
- Both AIs operate from the same
playbook
- Outputs are consistent and
repeatable
- Knowledge compounds rather than
resets
- Teams stop reinventing the wheel
for each issue
In short: you stop prompting from scratch. You start operating
from a system.
The Core Idea
You are not prompting tools. You are building an environment
those tools operate inside.
Think of it like this:
- Prompts = conversations
- Workspace = memory + rules +
context
The difference between:
“Help me fix this”
and
“Work like a senior developer on my team”
is the workspace.
How to Build the Workspace With AI
Building a workspace manually is slow and error-prone. Instead, let AI create,
structure, and populate the environment.
1. Let GitHub Copilot Bootstrap the
Initial Workspace
Copilot is perfect for scaffolding structures and templates.
Prompt example in VS Code Copilot Chat:
Act as a senior IBM i architect and
developer.
Create a GitHub repository structure for a shared AI workspace called "The
RPG Blend".
Include:
/ai
/rules
/context
/patterns
/prompts
/templates
/work-item-template
/examples
/sample-work-item
/docs
architecture.md
workflow.md
README.md
Populate README.md and each folder with Markdown explaining purpose, usage, and
best practices.
Create starter template files for work items: Code-Analysis.md,
Impact-Analysis.md, Solution-Options.md, Recommendation.md, Test-Plan.md.
Structure it so it is immediately usable by both Copilot and IBM Bob.
Outcome:
- /ai folder initialized
- README and documentation for each
folder
- Work-item templates ready
- A consistent structure that
aligns both AI tools
Copilot handles repetitive setup while human oversight ensures alignment
with organizational standards.
2. Let AI Draft Rules, Context, and
Patterns
Rules Prompt:
Generate an IBM i RPG coding standards
document including naming conventions, error handling, file access, SQL usage,
display file guidelines, and logging. Format as Markdown under
/ai/rules/ibmi-standards.md.
Context Prompt:
Document the system context for the AI
workspace. Include architecture, database structure, historical decisions,
quirks, and accession number behavior. Format as Markdown for /ai/context/.
Patterns Prompt:
Document recurring coding patterns,
best practices, and pitfalls in IBM i RPG development. Create Markdown files
under /ai/patterns/, including examples and usage instructions.
Result:
A structured knowledge base that both Copilot and Bob can reference. It ensures
consistent outputs for every work item.
3. Let IBM Bob Validate and Evolve the
Workspace
After Copilot scaffolds the workspace, Bob ensures compliance,
quality, and completeness.
Prompt example for IBM Bob:
Analyze the AI workspace in /ai and
/templates/work-item-template.
- Validate rules, context, and patterns against IBM i best practices.
- Identify gaps, inconsistencies, or ambiguous content.
- Suggest improvements to folder structure, naming conventions, and template
files.
- Generate updated Markdown files or notes for missing documentation.
- Ensure the workspace supports future AI prompts with shared knowledge.
Outcome:
- Workspace validated against
enterprise standards
- Gaps filled and inconsistencies
corrected
- Templates improved for clarity
and reusability
- Knowledge becomes structured and
persistent
4. Using the Workspace for Work Items
Once the workspace is ready, both Copilot and Bob operate from a
shared memory and ruleset.
Copilot Example Prompt:
Act as a senior IBM i RPG developer.
Analyze work item CL-14797 using:
/ai/rules/ibmi-standards.md
/ai/context/accession-number-behavior.md
Output code analysis, impact, solution options, recommendation, and test plan
into /CL-14797 as Markdown.
Bob Example Prompt:
Validate CL-14797 analysis.
- Use /ai rules and context.
- Identify deviations from IBM i best practices.
- Suggest improvements or risk mitigations.
- Write additional notes back to /ai workspace.
Iterative Loop:
- Copilot generates initial
analysis
- Bob validates and critiques
- Copilot refines solutions
- Workspace updated
- Next work ite
m begins ahead
This creates a closed-loop AI system, where knowledge grows
instead of resetting.
5. Using AI to Continuously Improve
the Workspace
The workspace is a living system. Use AI to regularly improve and
update it:
- New rules: After resolving issues, ask
Copilot to propose updates based on new patterns.
- Audit for consistency: Bob can periodically scan the
workspace and highlight gaps or outdated information.
- Pattern evolution: Copilot can suggest reusable
patterns after analyzing multiple work items.
- Prompt library updates: Both AIs can add new prompts for
recurring scenarios.
Example Prompt for Continuous Improvement:
Review all work items in /CL-*.
- Identify recurring solutions or repeated errors.
- Suggest new patterns or best practices.
- Update /ai/patterns/ with Markdown files including examples.
- Update /ai/prompts/ for recurring tasks.
- Flag outdated or contradictory content for pruning.
This keeps the workspace fresh, relevant, and aligned with evolving
standards.
6. Maintaining the Workspace
Treat the workspace like versioned code:
- Version control: Track all
changes
- Review: Conduct periodic checks
- Refactor: Update obsolete rules
or patterns
- Prune: Remove experiments or
redundant files
Update after every decision:
- Add lessons learned
- Update rules
- Capture quirks and edge cases
This ensures your AI always has a trusted, living environment.
Patterns That Work
- Always anchor prompts to /ai files — never vague instructions
- Force outputs to locations — ensures persistence
- Separate analysis,
recommendation, and implementation — don’t mix thinking with fixing
Common Mistakes
- Treating AI like Google: you get
answers, not systems
- No shared context: every prompt
starts from zero
- Standards undocumented: if it’s
not in /ai/rules, it doesn’t exist
What This Looks Like in Practice
Walk into a new issue:
Instead of asking:
“What’s wrong?”
You prompt:
“Use the workspace. Analyze. Write findings.”
Within minutes you have:
- Root cause
- Impact
- Options
- Recommendation
- Test plan
Consistent. Structured. Repeatable.
Final Sip
That last coffee—slightly cooler, a little stronger at the bottom—tells
the truth.
This approach is disciplined, structured, and effective.
You’re building a system where:
- Knowledge persists
- AI aligns
- Teams move faster without losing
control
Most teams keep prompting. A few build environments.
Build the environment.
What’s Next
This isn’t just an idea. It’s a system you can use.
I’ll be publishing the full prompt library to GitHub as part of The
RPG Blend—including everything needed to:
- Build the workspace
- Run Copilot effectively
- Use IBM Bob for validation
- Maintain and evolve the system
If you’re serious about using AI at a higher level, don’t just read this.
Use it.
-George VanEaton
Comments
Post a Comment