Skip to content
/

roomodes (sellisd)

roomodes-sellisd · sellisd/roomodes · ★ 23 · last commit 2025-04-10

Simulate a full agile scrum team (PO, SM, Dev, QA) in Roo Code using per-role Jira-integrated personas.

Best whenJira is the coordination bus between AI agent roles; each mode must update tickets before switching.
Skip ifActing without checking Jira first, Switching modes without committing and documenting state
vs seeds
bmad-method(named agent personas with distinct roles), but uses Roo Code's JSON .roomodes format instead of TOML+Markdown, and uniq…
Primitive shape 7 total
Subagents 5 MCP tools 2
00

Summary

roomodes (sellisd) — Summary

roomodes by sellisd is a collection of five custom Roo Code modes that simulate a full agile scrum team: Product Owner, Scrum Master, Tech Lead, Developer, and QA Engineer. Each mode ships as a JSON persona definition plus a companion .roorules-* file containing detailed behavioral instructions for that role. A Python installer script (modes_installer.py) copies modes and rule files into any target project and configures Jira (via mcp-atlassian) and GitHub (via Docker-based github-mcp-server) MCP connections. The collection is opinionated about Jira-centric project management: every mode includes explicit instructions for reading, updating, and transitioning Jira tickets as part of its workflow. The framework enables multi-agent simulation within a single Roo Code instance by letting users switch modes at sprint boundaries. It differs from the superpowers seed (single behavioral pack for one AI agent) by modeling an entire team of distinct personas, each with their own tool-access restrictions and Jira MCP workflows; the closest seed analog is BMAD-METHOD's persona pattern, but sellisd's personas are JSON-configured rather than TOML+MD and are purpose-built for Jira-backed scrum rather than software architecture.

01

Overview

roomodes (sellisd) — Overview

Origin

Created by sellisd (GitHub user), first published in early 2025. The repository is named roomodes and lives at https://github.com/sellisd/roomodes. No formal blog post or manifesto is present; motivation is stated in the README:

"A collection of custom Roo modes that work together as an agile team. This collection enables multiple developers and AI agents to collaborate effectively on large projects by providing specialized roles with clear responsibilities and interaction patterns."

Philosophy

The core idea is role specialization over generalism: rather than one AI agent wearing all hats, each Roo mode is given a narrowly scoped persona with corresponding Jira MCP permissions. The framework treats AI modes as proxies for human team roles, enforcing agile rituals (sprint planning, retrospective, backlog grooming) via explicit instructions in each mode's custom instructions block.

There is no manifesto-level document. The README describes mode interaction patterns via a Mermaid sequence diagram showing the canonical handoff flow:

PO --Create Sprint--> SM
SM --Request Technical Review--> TL
TL --Provide Technical Guidelines--> DEV
DEV --Submit Implementation--> QA
QA --Report Testing Status--> SM
SM --Update Sprint Progress--> PO

Key Design Opinions

  1. Jira is the source of truth — all modes include instructions to check Jira before acting and update Jira after acting.
  2. Git automation per mode — each .roorules-* file enables autoCommit: true with a mode-specific commit message prefix (e.g., [roo-po], [roo-sm]), and commits before mode switches.
  3. Minimal file-system access — modes restrict edits to .md and .json files only; broader file access is not granted to non-developer modes.
  4. External MCP dependency — the mcp-atlassian server and docker-based GitHub MCP server are required, not optional.

Target Audience

Teams using Roo Code for multi-role AI-assisted development on Jira-managed projects. The framework explicitly does not work without Jira credentials.

02

Architecture

roomodes (sellisd) — Architecture

Distribution Type

bash-script-bundle — the repository is cloned; a Python installer script (modes_installer.py) copies files into the target project.

Install

git clone https://github.com/sellisd/roomodes
cd roomodes
pip install pathlib   # stdlib in Python 3.4+ — no actual install needed
./modes_installer.py --target /path/to/your/project

Prerequisites:

  • Jira API key from Atlassian Cloud
  • GitHub personal access token
  • uvx (for mcp-atlassian) OR Docker (for github-mcp-server)

Directory Tree (source repo)

roomodes/
├── modes/
│   ├── cicd-specialist.json
│   ├── product-owner.json
│   ├── qa.json
│   ├── scrum-master.json
│   └── uiux-designer.json
├── roorules/
│   ├── .roorules-architect
│   ├── .roorules-cicd
│   ├── .roorules-code
│   ├── .roorules-product-owner
│   ├── .roorules-qa
│   ├── .roorules-scrum-master
│   └── .roorules-uiux
├── mcp-config/
│   └── default.json        # Jira + GitHub MCP server config template
├── modes_installer.py      # Python installer
└── README.md

Files Installed Into Target Project

<target-project>/
├── .roomodes               # Generated from modes/*.json (all 5 personas)
└── .roo/
    ├── mcp.json            # Copied from mcp-config/default.json
    ├── .roorules-product-owner
    ├── .roorules-scrum-master
    ├── .roorules-cicd
    ├── .roorules-code
    ├── .roorules-qa
    └── .roorules-uiux

Required Runtime

  • Python 3.4+ (for installer)
  • Roo Code extension in VS Code / Cursor
  • uvx + mcp-atlassian (Jira MCP)
  • Docker + ghcr.io/github/github-mcp-server (GitHub MCP)

Target AI Tools

  • Roo Code (primary; .roomodes and .roorules-* are Roo-specific)
  • Cursor compatibility: partial (.roorules not natively used by Cursor)

Config Files

  • .roomodes — root-level Roo mode config
  • .roo/mcp.json — MCP server connection config
  • .roorules-* — per-mode behavioral rules
03

Components

roomodes (sellisd) — Components

Mode Definitions (JSON persona files in modes/)

File Mode Slug Description
product-owner.json product-owner Manages product backlog, writes user stories, maintains roadmap, uses Jira MCP for backlog management
scrum-master.json scrum-master Facilitates scrum ceremonies, manages sprint execution, tracks velocity, removes impediments
qa.json qa Develops test strategies, manages test cases, tracks quality metrics, reports bugs
cicd-specialist.json cicd-specialist Manages CI/CD pipelines, deployment automation, and DevOps workflows
uiux-designer.json uiux-designer Creates UI/UX specifications, design documentation, and interface guidelines

Note: The README lists a "Tech Lead" and "Developer" mode, but the modes/ directory contains cicd-specialist and uiux-designer instead. The README predates the actual implementation.

Roorules Files (in roorules/)

File Purpose
.roorules-product-owner Git autoCommit config + Jira workflow instructions for PO
.roorules-scrum-master Git autoCommit config + sprint management instructions
.roorules-code Coding standards and implementation guidelines
.roorules-architect Architecture decision-making instructions
.roorules-cicd CI/CD pipeline management rules
.roorules-qa QA process and test strategy instructions
.roorules-uiux UI/UX design process rules

Scripts

File Purpose
modes_installer.py Python script — reads modes/*.json, generates .roomodes, copies .roorules-* to target project's .roo/, sets up mcp.json

MCP Config Template

File Purpose
mcp-config/default.json Template for .roo/mcp.json with mcp-atlassian (Jira) and ghcr.io/github/github-mcp-server (GitHub) configured

Hooks

None defined. The .roorules-* files contain git.autoCommit: true settings which Roo Code interprets, but these are not Claude Code lifecycle hooks.

Total Primitive Count

  • Modes (subagent personas): 5
  • Roorules (behavioral instruction sets): 7
  • Scripts: 1
  • MCP templates: 1
05

Prompts

roomodes (sellisd) — Prompts

Excerpt 1: Product Owner Mode Definition (modes/product-owner.json)

{
  "slug": "product-owner",
  "name": "Product Owner",
  "roleDefinition": "You are Roo, an experienced Product Owner with expertise in agile methodologies. Your responsibilities include:\n- Managing product backlog and prioritization\n- Writing and refining user stories\n- Creating and maintaining product roadmaps\n- Collaborating with stakeholders\n- Making product decisions based on data and feedback. Gather input from the user to shape user stories and requirements.",
  "groups": [
    "read",
    ["edit", { "fileRegex": "\\.md$|\\.json$", "description": "Can edit Markdown and JSON files" }],
    "mcp",
    "command"
  ],
  "customInstructions": "1. Use Jira MCP tools for backlog management\n2. Maintain product documentation in Markdown\n3. Ensure user stories follow INVEST principles\n4. Link stories to epics and track progress\n5. Collaborate with Scrum Master for sprint planning\n6. Review and accept completed work based on definition of done\n7. Before making changes:\n   - Check if related Jira tickets exist\n   - Ensure changes align with product roadmap\n   - Consider impact on current sprint\n8. After changes:\n   - Update relevant Jira tickets\n   - Notify team of significant changes\n   - Document decisions in product documentation\n9. If an action is not allowed or you encounter a limitation of the mcp tools or APIs you are using ask the user suggesting the manual action to take."
}

Prompting technique: Persona injection with role definition + scoped file access groups + numbered behavioral checklist. The groups array restricts the mode to read + limited edit (.md/.json only) + MCP + command — enforcing capability boundaries at the framework level rather than relying on instruction alone.


Excerpt 2: Scrum Master Roorules (.roorules-scrum-master)

{
  "git": {
    "autoCommit": true,
    "commitMessage": "[roo-sm] {description}",
    "commitBeforeSwitch": true,
    "commitBeforeExit": true
  },
  "customInstructions": [
    "Sprint management:",
    "1. Monitor sprint health and team velocity",
    "2. Track and resolve impediments",
    "3. Maintain sprint documentation and metrics",
    "",
    "Scrum ceremonies:",
    "1. Facilitate daily standups",
    "2. Lead sprint planning sessions",
    "3. Guide sprint reviews",
    "4. Conduct effective retrospectives",
    "",
    "Mode interactions:",
    "1. Sync with Product Owner on backlog and priorities",
    "2. Support Tech Lead in technical planning",
    "3. Help QA with test planning integration",
    "4. Guide Developer mode in agile practices",
    "",
    "Before mode transitions:",
    "1. Update sprint board status",
    "2. Document any open impediments",
    "3. Ensure ceremony outcomes are recorded"
  ]
}

Prompting technique: State-machine instructions with explicit pre-condition checks before mode transitions. Git automation embedded in the rules file. The pattern forces Roo Code to commit and document before switching contexts, preserving audit trail across role changes.


Excerpt 3: Scrum Master roleDefinition (modes/scrum-master.json)

"You are Roo, an experienced Scrum Master with expertise in agile methodologies. Your responsibilities include:\n- Facilitating scrum ceremonies and team collaboration\n- Removing impediments and supporting the team\n- Managing sprint execution and team velocity\n- Ensuring agile best practices\n- Promoting continuous improvement through retrospectives"

Prompting technique: Compact identity + responsibility enumeration. No elaborate reasoning chain; relies on the companion .roorules-* file for procedural detail.

09

Uniqueness

roomodes (sellisd) — Uniqueness

Differs From Seeds

The closest seed is BMAD-METHOD, which also uses named personas (Analyst, Architect, Developer, QA) loaded as distinct AI roles. However, BMAD uses TOML+Markdown persona files and targets Claude Code directly; roomodes uses Roo Code's JSON .roomodes format plus companion .roorules-* files. The critical architectural delta is Jira integration as first-class coordination: every roomodes persona is explicitly instrumented to read/update Jira before and after actions, making Jira the cross-mode state bus. BMAD has no equivalent external project management integration. The second seed difference: BMAD personas can all be active in a session via orchestration; roomodes personas are mutually exclusive (one active at a time, manual switching).

Compared to superpowers, roomodes has no hooks, no context compaction handling, and is entirely Roo Code-specific (single-tool vs. superpowers' multi-tool portability).

Compared to agent-os, roomodes ships runnable personas rather than documentation templates. Agent-OS writes standards/ markdown; roomodes ships .roomodes JSON that actually configures Roo Code behavior.

Positioning

  • Niche: Teams using Roo Code + Jira who want AI to simulate entire scrum team roles
  • Differentiation: The only framework in the corpus that treats Jira as the coordination bus and enforces per-role git commit prefixes for audit traceability
  • Limitation: Hard-coded Jira dependency; useless without Atlassian Cloud access. No equivalent for Linear, GitHub Projects, or other PM tools.

Observable Failure Modes

  1. Jira MCP misconfiguration — all modes rely on mcp-atlassian; if credentials are missing, every mode degrades to Markdown-only output
  2. Mode confusion — user switches modes prematurely; half-done Jira tickets accumulate
  3. Docker dependency — GitHub MCP requires Docker, which is not available in all environments
  4. README/code mismatch — README describes "Tech Lead" and "Developer" modes; the actual modes/ directory contains cicd-specialist and uiux-designer instead, indicating the README is outdated
  5. Single-agent bottleneck — sequential mode switching means no parallel work; large sprints are slow

Cross-References

  • Shares Roo Code targeting with roo-code-vibook and james-cherished-roo-community in this batch
  • MCP-anchored coordination is philosophically closest to taskmaster-ai (seed) but uses external Jira rather than local task files
04

Workflow

roomodes (sellisd) — Workflow

Phase Overview

The framework models a full agile sprint cycle, with each mode handling its sprint phase:

Phase Mode Artifact
1. Sprint Planning Product Owner → Scrum Master Sprint backlog in Jira, .md user stories
2. Architecture/Tech Review CI/CD Specialist Technical guidelines, architecture docs
3. Implementation Code mode (default) Source code files, unit tests
4. Quality Assurance QA mode Test reports, bug tickets in Jira
5. Sprint Review/Retro Scrum Master Retrospective notes, sprint metrics

Mode Handoff Protocol

Defined in .roorules-product-owner and .roorules-scrum-master:

  1. Before switching mode: commit current changes (autoCommit: true)
  2. Update relevant Jira ticket status
  3. Document any open impediments
  4. Notify team of significant changes (via Jira comment)

Approval Gates

The framework has no explicit human approval gates. Mode switching is manual (user selects mode in Roo Code UI). Jira ticket status transitions serve as implicit checkpoints.

Git Automation

Every .roorules-* file configures:

{
  "git": {
    "autoCommit": true,
    "commitMessage": "[roo-<mode>] {description}",
    "commitBeforeSwitch": true,
    "commitBeforeExit": true
  }
}

This means Roo Code commits changes automatically when switching modes or exiting.

Spec Format

No formal spec format. User stories are written to .md files following INVEST criteria (Independent, Negotiable, Valuable, Estimable, Small, Testable) as instructed in PO mode.

Artifacts Per Phase

Phase Primary Artifact
Sprint Planning .md user stories + Jira epic/story links
Tech Review Architecture decision docs (.md)
Implementation Source code + unit test files
QA Test case docs (.md) + Jira bug tickets
Sprint Close Retrospective notes (.md) + velocity metrics
06

Memory Context

roomodes (sellisd) — Memory & Context

State Storage

The framework relies on Jira as the external state store for project state (backlog, sprint, ticket status). Local filesystem state is managed via Git (commit history serves as audit trail).

No dedicated in-process memory or context database is used.

Persistence Mechanism

Artifact Storage Lifetime
Sprint state Jira (external) Project-scoped
User stories .md files in project Project-scoped
Mode transitions Git commits ([roo-sm] ... etc.) Project-scoped (git history)
MCP config .roo/mcp.json Project-scoped

Context Handoff Between Modes

The .roorules-* files instruct each mode to:

  1. Document current work state before switching modes
  2. Commit changes with a descriptive message
  3. Update Jira ticket status

No automatic context injection between sessions. A new Roo Code session starts fresh; Jira serves as the cross-session state.

Compaction

No context compaction mechanism. Relies on Roo Code's built-in context window management.

Cross-Session Handoff

Via Jira ticket status + Git commit history. There is no structured context file written for the next mode/session.

Memory Type

File-based + external (Jira). No local DB or vector store.

07

Orchestration

roomodes (sellisd) — Orchestration

Multi-Agent Pattern

The framework simulates multi-agent behavior through sequential mode switching rather than concurrent agents. At any time, only one mode (one "agent persona") is active in Roo Code. Orchestration is manual: the user switches modes at appropriate sprint phase boundaries.

Pattern: sequential (one mode active at a time)

Mode Interaction Diagram

Product Owner → Scrum Master → CI/CD Specialist → Code Mode → QA Mode → Scrum Master

Isolation Mechanism

No isolation (no git worktrees, no containers). All modes operate on the same working tree. The only separation is file-access group restrictions in mode definitions (e.g., PO mode can only edit .md and .json).

Multi-Model Routing

No multi-model routing. Roo Code uses whatever model the user has configured; no per-mode model assignment.

Execution Mode

interactive-loop — user drives mode transitions manually via Roo Code UI.

Consensus

None.

Subagent Spawn Mechanism

None (no programmatic agent spawning). Mode switching is manual.

Prompt Chaining

Not implemented. Each mode operates independently. The commit message convention ([roo-po], [roo-sm]) creates a structured handoff log but does not chain prompts.

MCP-Based Coordination

Jira MCP serves as the coordination bus: modes read from and write to Jira to communicate state, but this is convention-based (instructions in each mode's custom rules) rather than automated.

08

Ui Cli Surface

roomodes (sellisd) — UI / CLI Surface

Dedicated CLI Binary

None. The only executable is modes_installer.py, which is a one-time setup script, not an operational CLI.

Local Web Dashboard

None.

IDE Integration

Roo Code (VS Code extension) is the primary runtime surface:

  • .roomodes file is read by Roo Code to populate the mode switcher
  • .roorules-* files are loaded by Roo Code for the active mode
  • MCP servers are configured in .roo/mcp.json

Installer CLI

modes_installer.py accepts a --target flag:

./modes_installer.py --target /path/to/project

Functions:

  • Reads modes/*.json and writes .roomodes to target
  • Copies .roorules-* to <target>/.roo/
  • Copies mcp-config/default.json to <target>/.roo/mcp.json (if not already present)

Observability

  • Git commit history (prefixed commit messages per mode) provides a lightweight audit trail
  • Jira is the primary project state tracker
  • No log files, no structured audit trail beyond git

Installation Verification

The installer prints file names as they are copied. No post-install health check.

Related frameworks

same archetype · same primary tool · same memory type

BMAD-METHOD ★ 48k

Provides a full agile delivery lifecycle with named expert-persona AI collaborators that elicit the human's best thinking rather…

Agent OS ★ 4.6k

Extracts implicit codebase conventions into token-efficient markdown standards files and injects them selectively into AI agent…

Claude Conductor ★ 367

Gives Claude Code a persistent, cross-linked, auto-analyzed documentation system so it retains codebase context across sessions.

Spec-Driver (Greenfield Spec-Driven Development) ★ 25

Prevents spec rot in AI-assisted development by making implementation changes flow back into evergreen, authoritative specs via…

Anthropic Knowledge Work Plugins ★ 16k

Role-specialized plugin bundles with live MCP connectors that turn Claude into a domain expert for enterprise knowledge workers.

Codex Integration for Claude Code (skill-codex) ★ 1.3k

Single Claude Code skill that handles Codex CLI invocation correctly (stdin blocking, thinking token suppression, session resume)…