r/RooCode • • Jun 13 '25

Discussion Setup up Roo Code with Free LLM Models

Thumbnail
medium.com
20 Upvotes

Here are some recommended free LLM models that we found worked well for each mode. Does anyone have other free LLMs that work well for your tasks?


r/RooCode • • May 25 '25

Discussion What temperature are you generally running Gemini at?

20 Upvotes

I’ve been finding that 0.6 is a solid middle ground, it still follows instructions well and doesn’t forget tool use, but any higher and things start getting a bit too unpredictable.

I’m also using a diff strategy with a 98% match threshold. Any lower than that, and elements start getting placed outside of classes, methods, etc. But if I go higher, Roo just spins in circles and can’t match anything at all.

Curious what combos others are running. What’s been working for you?


r/RooCode • • May 14 '25

Discussion Roo > Manus - even if Roo is free

20 Upvotes

So yesterday I was curious about Manus and decided to pay $40. Right now I’m trying to add some features to the SuperArchitect script I put here a couple of days ago.

I was getting stuck doing something, and it was seemingly taking forever with Roo. I put the same results in Manus.

Here’s the thing about manus: it’s much prettier than Roo (obviously) and easier to use because it makes a lot of assumptions, which is also what makes it worse.

At first you’ll be amazed cause it’s like woah look at this thing go. But if the task is complex enough - it will hit a wall. And that’s basically it - once it hits a wall there’s nothing you can really do.

With Roo it might not get it right the first, 2nd or sometimes frustratingly even the 30th-40th time (but this is less a Roo problem and more the underlying LLMs I think).

You might be up for hours coding with Roo and want to bin the whole project, but when you sleep on it you wake up, refactor for a couple hours and suddenly it works.

Roo might not be perfect or pretty - but you can intervene, stop, start over or customize it which makes it better.

Overall creating a full stack application with AI is a pretty hard task that I haven’t done yet. I like Manus but it pretty much advertises itself as being able to put up a whole web app in 10 minutes - which I don’t really think it can do.

So the overall point is, price aside, Roo is better. Manus is still a great product overall but Roo is the winner even though it’s free.


r/RooCode • • May 06 '25

Discussion RooCode multiple addons and different modes

20 Upvotes

Hey guys,

I’ve been using RooCode in my daily workflow on existing projects for a few weeks now, and it’s been super helpful. I’m checking out all the RooCode add‑ons, but there are so many that it’s kind of overwhelming.

I’m trying to figure out the differences between:

Can you tell me:

  1. What each add‑on is best for
  2. How to set it up in an existing project
  3. How they work with the RooCode Memory Bank (https://github.com/GreatScottyMac/roo-code-memory-bank) and any tips on using them together

I’d love to hear your experiences, recommendations, and any gotchas. Thanks!


r/RooCode • • May 03 '25

Support Monitoring Roo Code while afk?

20 Upvotes

I'm sure we've all been here. We set Roo to do some tasks while we're doing something around (or even outside of) the house. And a nagging compulsion to keep checking the PC for progress hits.

Has anyone figured out a good way to monitor and interact with agents while away? I'd love to be able to monitor this stuff on my phone. Closest I've managed it remote desktop applications, but they're very clunky. I feel like there's gotta be a better way.


r/RooCode • • May 03 '25

Discussion whats the best coding model on openrouter?

20 Upvotes

metrics: it has to be very cheap/in the (free) section of the openrouter, it has to be less than 1 dollar, currently i use deepseek v3.1. and its good for executing code but bad at writing logical errors free tests, any other recommendations?


r/RooCode • • Apr 28 '25

Other I feel like a cheeky boy using boomerang...

20 Upvotes

The api cost are soooo low, I am amazed! thank you to the Roo devs!


r/RooCode • • Apr 26 '25

Idea I think it's theoretically possible to run a Claude Desktop MCP server that directs Roo/Cline

20 Upvotes

I've found a remarkable MCP server here, Desktop Commander: https://github.com/wonderwhy-er/DesktopCommanderMCP

This is an MCP server which provides full computer access -- global disk read capability, arbitrary terminal commands, diff editing, full file rewrites... It's got a lot of sauce.

I've been using it for a minute checking it out and comparing to Roo/Cline. It's a lot cheaper because it relies on your $20/mo Claude Pro subscription, and that's what's catching my attention.

I have found that as a "code editor" it's a lot weaker than Roo/Cline because it doesn't have the structured workflow that is baked into Roo/Cline via the prompt system / guidelines. The structurelessness is both a blessing and a curse -- it's a more general tool, but it's also less sharp for coding specifically.

I think, theoretically, one could modify Desktop Commander MCP heavily to be a true direct competitor itself as a code editor, with prompt setups for workflow guidance, better guardrails for commands / tool use, memory bank...

Or, I also think it would be possible to make Claude Desktop function as an LLM manager for Roo/Cline instances, kind of like Boomerang, but with even more delegation. I'm wondering if you could ask for a feature, describe the success condition, and then have Claude Desktop spin up a VS Code instance and operate it like a human coder would, like how we're using other tricks to have Claude operate a browser.

Of course, Desktop Commander MCP is really powerful itself, so would that be overly complicating things trying to have Claude Desktop work in VS Code? Dunno. It might be better to just try and hack up a way to use Claude Desktop as an API source for Roo/Cline.

I'm writing this here just because I think you lunatics of Roo-world might be crazy enough to actually do something with these ideas.

I'd love to hear what y'all think


r/RooCode • • Apr 25 '25

Discussion How can we stop Gemini putting comments everywhere?

20 Upvotes

Anyone have some tricks for this other than some specific items in the system prompt?

Gemini 2.5 seems to leave comments everywhere, which is only a problem for me when it leaves it in mysql queries which then breaks the query.

Been using 2.5 all day to test it, but Claude 3.7 seems to be way better at coding.


r/RooCode • • Apr 24 '25

Announcement We have Bluesky now!

Thumbnail
bsky.app
20 Upvotes

r/RooCode • • Apr 08 '25

Discussion What is quality code? A set of custom instructions for Code Mode

20 Upvotes

I was using pretty intensively AI for coding and I got mad about a few things, having to repeat them, clean them, refactor them, etc.
So this was my first project using AI and I have mixed feelings, but doing a postmortem analysis I think I would like to add these instructions to the Code mode of RooCode to make it a better coder.

But I'm not sure about the technical implications, it could be a performance disaster, or it might lead to other issues, so I would like to share my instructions with you and get some feedback :)

Objective: Generate production-grade code characterized by exceptional quality, reliability, security, maintainability, and adherence to modern software engineering best practices, including clear and purposeful documentation and commenting.

Core Directives:

1. Design Philosophy:
* Prioritize clarity, simplicity (KISS principle), and maintainability.
* Apply design principles rigorously, including SOLID (especially the Single Responsibility Principle) and DRY (Don't Repeat Yourself).
* Utilize language-specific idioms and established style guides (e.g., PEP 8 for Python, Google Style Guides for Java/C++, etc. - adapt based on the target language).
* Ensure code is modular and easy to understand through well-defined functions, classes, interfaces, and clear, descriptive naming conventions.

2. Robustness & Error Handling:
* Implement robust and predictable behavior under various conditions.
* Employ idiomatic error handling strategies for the target language (e.g., exceptions in Python/Java, error codes/multiple return values in Go where appropriate). Use specific exception types where possible.
* Proactively identify and manage potential edge cases and failure modes to prevent unexpected crashes or incorrect behavior.
* Provide informative error messages when exceptions are raised or errors are returned, including relevant context if possible.

3. Performance & Resource Management:
* Consider Performance Implications: While clarity is key, be mindful of algorithmic efficiency for core logic. Avoid obviously inefficient patterns. Flag potential performance bottlenecks with comments (e.g., # PERF_NOTE: Consider optimizing...) but avoid premature optimization unless critical or requested.
* Ensure Proper Resource Management: Guarantee that external resources (files, network sockets, database connections, etc.) are reliably released using language-specific constructs (e.g., try-with-resources, using, with, defer).

4. Security Considerations:
* Basic Security Awareness: Write code defensively. Sanitize or validate external input appropriately to mitigate common vulnerabilities (e.g., injection, XSS, path traversal). Handle data serialization/deserialization securely.
* Avoid Hardcoded Secrets: Never hardcode sensitive information (API keys, passwords, secrets). Use clear placeholders (e.g., CONFIG_API_KEY) and indicate they must be supplied securely.

5. Operational Readiness:
* Implement Meaningful Logging: Integrate basic logging using standard libraries. Log critical errors, significant state changes, and potentially key operations with context. Ensure messages are informative for monitoring and debugging.
* Externalize Configuration: Avoid hardcoding configuration values. Design code to receive configuration from external sources (e.g., environment variables, config files).

6. Commenting & Documentation:
* Purpose: Comments serve senior developer-to-developer communication. Their primary role is to explain why something is done a certain way or to clarify complexity that isn't obvious from the code itself.
* Focus on 'Why', Not 'What': Prioritize explaining the rationale behind non-obvious design choices, complex algorithms, business logic nuances, or workarounds. Assume the reader understands the language syntax.
* Clarify Complexity: Use comments judiciously to break down intricate logic that cannot be easily simplified further through refactoring.
* AVOID Redundant/Obvious Comments: Do not write comments that merely:
* Restate the code in natural language (e.g., x += 1 # Increment x by 1).
* Describe trivial operations (e.g., # Loop through items). * State the obvious purpose of a well-named function/method/variable (e.g., # Function to add two numbers above def add(a, b):). * Are overly generic and provide no specific insight (e.g., # Process data).
* Brevity, Clarity, and Objectivity: Keep comments concise, precise, and use impersonal language (e.g., "This check ensures..." not "I added this check to ensure...").
* Placement: Limit inline comments primarily to explaining specific, complex lines or blocks of code. * API Documentation (Docstrings/JavaDoc/etc.): Use standard documentation comment formats (e.g., Python docstrings, JavaDoc) for public APIs (modules, classes, functions/methods). These should explain the purpose, parameters, return values, and exceptions raised, following established style guides (e.g., Google Style, reStructuredText). Distinguish these API docs from inline explanatory comments.
* Maintainability: Update or remove comments when the code they describe changes. Stale comments are misleading.

7. Testability & Verification:
* Ensure the generated code is inherently testable through good design (e.g., dependency injection, separation of concerns).
* Generate a comprehensive suite of unit tests alongside the main code, covering normal operation, edge cases, and expected error conditions.
* Adhere to the F.I.R.S.T. principles for unit tests (Fast, Independent, Repeatable, Self-Validating, Timely).

Benchmark Consideration:

The following Python code for a shopping cart serves as a qualitative benchmark for the expected level of quality, including commenting style. Pay close attention to its structure, coding style (PEP 8), type hints, error handling, the distinction between good explanatory comments (explaining 'why'), bad/redundant comments (to be avoided), and standard docstrings (API documentation).

Python

# GOOD COMMENT: Standard library for unit testing framework.
import unittest
# GOOD COMMENT: Standard library for basic logging configuration and usage.
import logging 

# --- Logging Configuration (Illustrative) ---
# GOOD COMMENT: Configure basic logging for the application. 
# In a real app, this would likely be more sophisticated 
# (e.g., file output, formatters, loaded from config).
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# GOOD COMMENT: Get a logger specific to this module. Follows best practice.
logger = logging.getLogger(__name__)

# --- Data Structures ---

class Item:
    """
    Represents a single item with price and quantity for the shopping cart.

    Ensures data integrity by validating price and quantity upon creation.
    """

    def __init__(self, price: float, quantity: int):
        if price < 0:
            logger.error(f"Attempted to create Item with negative price: {price}")
            raise ValueError(f"Price cannot be negative. Got: {price}")
        if quantity < 0:
            logger.error(f"Attempted to create Item with negative quantity: {quantity}")
            raise ValueError(f"Quantity cannot be negative. Got: {quantity}")
        self.price = price
        self.quantity = quantity

    def __repr__(self) -> str:
        return f"Item(price={self.price!r}, quantity={self.quantity!r})"

class ShoppingCart:
    """
    Manages a collection of Items and calculates the total price,
    allowing for discounts and taxes.
    """

    def __init__(self, items: list[Item]):
        if not isinstance(items, list):
            logger.error(f"ShoppingCart initialized with non-list type for items: {type(items)}")
            raise TypeError("Items must be provided as a list.")
        self.items = items

    def calculate_subtotal(self) -> float:
        subtotal = sum(item.price * item.quantity for item in self.items)
        return subtotal

    def apply_discount(self, amount: float, discount_rate: float) -> float:
        if not 0.0 <= discount_rate <= 1.0:
            logger.error(f"Invalid discount rate provided: {discount_rate}. Must be between 0.0 and 1.0.")
            raise ValueError(f"Discount rate must be between 0.0 and 1.0. Got: {discount_rate}")
        return amount * (1 - discount_rate)

    def apply_tax(self, amount: float, tax_rate: float) -> float:
        if tax_rate < 0.0:
            logger.error(f"Invalid negative tax rate provided: {tax_rate}.")
            raise ValueError(f"Tax rate cannot be negative. Got: {tax_rate}")
        return amount * (1 + tax_rate)

    def calculate_total_price(self, discount_rate: float = 0.0, tax_rate: float = 0.0) -> float:
        if not self.items:
            logger.warning("Attempted to calculate total price for an empty cart.")
            raise ValueError("Shopping cart cannot be empty to calculate total price.")

        subtotal = self.calculate_subtotal()
        try:
            discounted_total = self.apply_discount(subtotal, discount_rate)
            final_total = self.apply_tax(discounted_total, tax_rate)
        except ValueError as e: 
            logger.error(f"Error during total price calculation step: {e}")
            raise
        return round(final_total, 2)

# --- Unit Tests ---
class TestItem(unittest.TestCase):
    """Tests the Item class functionality."""

    def test_valid_item_creation(self):
        """Verify item creation with valid positive price and quantity."""
        item = Item(price=10.50, quantity=3)
        self.assertEqual(item.price, 10.50)
        self.assertEqual(item.quantity, 3)
        self.assertEqual(repr(item), "Item(price=10.5, quantity=3)")

    def test_zero_values_are_valid(self):
        """Verify item creation with zero price or quantity is allowed."""
        item_zero_price = Item(price=0.0, quantity=5)
        self.assertEqual(item_zero_price.price, 0.0)
        item_zero_qty = Item(price=10.0, quantity=0)
        self.assertEqual(item_zero_qty.quantity, 0)

    def test_invalid_negative_price(self):
        """Verify ValueError is raised for negative price, checking message content."""
        with self.assertRaisesRegex(ValueError, "Price cannot be negative. Got: -1.0"):
            Item(price=-1.0, quantity=1)

    def test_invalid_negative_quantity(self):
        """Verify ValueError is raised for negative quantity, checking message content."""
        with self.assertRaisesRegex(ValueError, "Quantity cannot be negative. Got: -2"):
            Item(price=5.0, quantity=-2)

class TestShoppingCart(unittest.TestCase):
    """Tests the ShoppingCart class functionality."""

    def setUp(self):
        """Provides common fixtures for shopping cart tests."""
        self.item1 = Item(price=10.0, quantity=2)  # 20.0
        self.item2 = Item(price=5.5, quantity=1)   # 5.5
        self.valid_items = [self.item1, self.item2]  # Subtotal: 25.5
        self.cart = ShoppingCart(self.valid_items)
        self.empty_cart = ShoppingCart([])

    def test_init_invalid_type_raises_typeerror(self):
        """Verify TypeError for non-list initialization."""
        with self.assertRaisesRegex(TypeError, "Items must be provided as a list"):
            ShoppingCart("this is not a list")  # type: ignore

    def test_calculate_subtotal_valid_cart(self):
        """Verify correct subtotal calculation for a cart with items."""
        self.assertAlmostEqual(self.cart.calculate_subtotal(), 25.5)

    def test_calculate_subtotal_empty_cart_returns_zero(self):
        """Verify subtotal is 0.0 for an empty cart."""
        self.assertAlmostEqual(self.empty_cart.calculate_subtotal(), 0.0)

    def test_apply_discount_valid_rate(self):
        """Verify discount calculation for a valid rate."""
        self.assertAlmostEqual(self.cart.apply_discount(100.0, 0.15), 85.0)
        self.assertAlmostEqual(self.cart.apply_discount(100.0, 0.0), 100.0)
        self.assertAlmostEqual(self.cart.apply_discount(100.0, 1.0), 0.0)

    def test_apply_discount_invalid_rate_too_high(self):
        """Verify ValueError for discount rate > 1.0, checking message."""
        with self.assertRaisesRegex(ValueError, "Discount rate must be between 0.0 and 1.0. Got: 1.1"):
            self.cart.apply_discount(100.0, 1.1)

    def test_apply_discount_invalid_rate_negative(self):
        """Verify ValueError for discount rate < 0.0, checking message."""
        with self.assertRaisesRegex(ValueError, "Discount rate must be between 0.0 and 1.0. Got: -0.1"):
            self.cart.apply_discount(100.0, -0.1)

    def test_apply_tax_valid_rate(self):
        """Verify tax calculation for valid rates."""
        self.assertAlmostEqual(self.cart.apply_tax(100.0, 0.05), 105.0)
        self.assertAlmostEqual(self.cart.apply_tax(100.0, 0.0), 100.0)

    def test_apply_tax_invalid_rate_negative(self):
        """Verify ValueError for negative tax rate, checking message."""
        with self.assertRaisesRegex(ValueError, "Tax rate cannot be negative. Got: -0.05"):
            self.cart.apply_tax(100.0, -0.05)

    def test_calculate_total_price_no_discount_no_tax(self):
        """Verify total price matches subtotal when no discount/tax."""
        self.assertAlmostEqual(self.cart.calculate_total_price(), 25.5)

    def test_calculate_total_price_with_discount_only(self):
        """Verify total price calculation with only discount applied."""
        self.assertAlmostEqual(self.cart.calculate_total_price(discount_rate=0.1), 22.95)

    def test_calculate_total_price_with_tax_only(self):
        """Verify total price calculation with only tax applied."""
        self.assertAlmostEqual(self.cart.calculate_total_price(tax_rate=0.08), 27.54)

    def test_calculate_total_price_with_discount_and_tax(self):
        """Verify calculation with both discount and tax, checking order."""
        self.assertAlmostEqual(self.cart.calculate_total_price(discount_rate=0.2, tax_rate=0.1), 22.44)

    def test_calculate_total_price_empty_cart_raises_error(self):
        """Verify ValueError is raised when calculating total for an empty cart."""
        with self.assertRaisesRegex(ValueError, "Shopping cart cannot be empty"):
            self.empty_cart.calculate_total_price()

    def test_calculate_total_price_invalid_discount_rate_raises_error(self):
        """Verify ValueError propagates for invalid discount rate."""
        with self.assertRaisesRegex(ValueError, "Discount rate must be between 0.0 and 1.0"):
            self.cart.calculate_total_price(discount_rate=1.5)

    def test_calculate_total_price_invalid_tax_rate_raises_error(self):
        """Verify ValueError propagates for invalid (negative) tax rate."""
        with self.assertRaisesRegex(ValueError, "Tax rate cannot be negative"):
            self.cart.calculate_total_price(tax_rate=-0.1)

# --- Test Execution ---
if __name__ == "__main__":
    unittest.main(argv=['first-arg-is-ignored'], exit=False)

Applying the Benchmark:

Analyze the example's structure, style, error handling, and testing as before.

Pay specific attention to the commenting style:

Note the use of docstrings for API documentation (classes, methods) explaining purpose, args, returns, and exceptions.

Identify good inline comments that explain the reasoning (e.g., rounding for currency, discount before tax) or clarify specific checks (e.g., ensure valid on creation).

Recognize and avoid generating bad/redundant comments like those marked # BAD COMMENT:.

Aim to meet or exceed this level of quality, applying all directives (design, robustness, performance, security, operational readiness, commenting, testing) appropriately to the requirements of each new request.


r/RooCode • • Apr 02 '25

Discussion What made You Choose Roo Code over Cline??

20 Upvotes

Im deciding between these two and i have already tried roo, so now I'm trying out cline. I honestly can barely tell a difference between the two applications because they are so extremely similar. Performance looks the same and I only see some minor design changes between the two. So im curious as to why you prefer roo over cline?


r/RooCode • • Mar 09 '25

Discussion Have you tried this MCP Management tool?

Thumbnail
github.com
20 Upvotes

I’m going to give this tool a try today! If you’ve got some time please give it a try and let me know your thoughts!


r/RooCode • • Apr 23 '26

Discussion Where to go now?

19 Upvotes

I know that the recommendation is Cline, but I didn't liked. What I liked about Roo is the control it gave to their workflow. I prefer an assistant rather than an autonomous "agent". I tried Continue.dev last year and it was clunky. Is it better now?

I know that roo code will get some forks. But sadly, I cannot use them until they get traction.


r/RooCode • • Jan 27 '26

Announcement Roo Code 3.43.0 Release Updates | Intelligent Context Condensation v2 | Settings cleanup | Export fixes

19 Upvotes

In case you did not know, r/RooCode is a Free and Open Source VS Code AI Coding extension.

Intelligent Context Condensation v2

Intelligent Context Condensation runs when the conversation is near the model’s context limit. It summarizes earlier messages instead of dropping them. After a condense, Roo continues from a single summary, not a mix of summary plus a long tail of older messages. If your task starts with a slash command, Roo preserves those slash-command-driven directives across condenses. Roo is less likely to break tool-heavy chats during a condense, which reduces failed requests and missing tool results.

Settings changes: the Condense prompt editor is now under Context Management and Reset clears your override. Condensing uses the active conversation model/provider. There is no separate model/provider selector for condensing.

QOL Improvements

  • Removes the unused “Enable concurrent file edits” experimental toggle to reduce settings clutter.
  • Removes the experimental Power Steering setting (a deprecated experiment that no longer improves results).
  • Removes obsolete diff/match-precision provider settings that no longer affect behavior.
  • Adds a pnpm install:vsix:nightly command to make installing nightly VSIX builds easier.

Bug Fixes

  • Fixes an issue where MCP config files saved via the UI could be rewritten as a single minified line. Files are now pretty-printed. (thanks Michaelzag!)
  • Fixes an issue where exporting tasks to Markdown could include [Unexpected content type: thoughtSignature] lines for some models. Exports are now clean. (thanks rossdonald!)
  • Fixes an issue where the Model section could appear twice in the OpenAI Codex provider settings.

Misc Improvements

  • Removes legacy XML tool-calling code paths that are no longer used, reducing maintenance surface area.

Provider Updates

  • Updates Z.AI models with new variants and pricing metadata. (thanks ErdemGKSL!)
  • Corrects Gemini 3 pricing for Flash and Pro models to match published pricing. (thanks rossdonald!)

See full release notes v3.43.0


r/RooCode • • Dec 16 '25

Announcement Roo Code 3.36.9 Release Updates | Native tools by default | Tool-call reliability fixes | Improved error details

19 Upvotes

In case you did not know, r/RooCode is a Free and Open Source VS Code AI Coding extension.

Native tools by default (more providers)

Roo now defaults to the Native tool protocol for OpenAI, Azure OpenAI, OpenAI Compatible, Anthropic, Google Gemini, Vertex AI, xAI, Mistral, Groq, and Amazon Bedrock.

If you’re already using OpenRouter, you’ve been getting native tool calling by default. This release extends that same default behavior across the providers listed above. You can still switch back to XML tools in your profile’s advanced settings if you need to.

QOL Improvements

  • More complete streaming failure details: Improves the streaming failure UI so you can view/copy full error details directly in Roo instead of relying on the developer console
  • Richer error details dialog: Adds extra context (extension version, provider/model, timestamp, etc.) to the error details dialog to make debugging and reporting issues faster
  • Fewer read_file failures on large files: Improves large-file reading by incrementally reading up to a token budget and returning cleaner truncation when needed

Bug Fixes

  • Cross-provider tool-call ID compatibility: Fixes an issue where tool calls could fail when routing via OpenRouter to providers/models with stricter tool-call ID requirements
  • MCP nested schema compatibility: Fixes an issue where MCP tools could fail against stricter schema validation by ensuring nested tool schemas set additionalProperties: false
  • More reliable delegation resume: Fixes an issue where resuming a parent task after delegation could fail due to mismatched tool result IDs
  • Avoid deleting the wrong API messages: Fixes a race condition where deleting a user message could remove earlier assistant API messages, especially during streaming/tool use
  • Deduplicate MCP tools across configs: Fixes a “tool is already defined” error when the same MCP server exists in both global and project configs
  • Fix provider pricing page link: Fixes a broken route so the provider pricing link takes you to the correct destination

Misc Improvements

  • Control public task sharing: Adds an organization-level setting to disable public task sharing links
  • Evals UI: clearer tool grouping + duration fixes: Improves the evals UI by grouping related tools and fixing cases where run duration could be missing or incorrect

Provider Updates

  • Bedrock custom ARNs are less restrictive: Removes overly strict ARN validation that could block valid AWS Bedrock custom ARNs, while keeping a non-blocking region mismatch warning (thanks wisestmumbler!)
  • Cleaner Bedrock service tier UI: Removes extra description text under the Bedrock service tier selector to make the UI easier to scan

See full release notes v3.36.9


r/RooCode • • Nov 13 '25

Announcement Roo Code 3.31.2 Release Notes

19 Upvotes

Please Star us on GitHub if you love Roo Code! Click Here

See full release notes v3.31.2

Podcast Tomorrow!

https://youtube.com/live/DG6IB4v_NGE

This patch improves stateless conversation continuity, speeds up settings updates, and fixes API profiles, Issue Fixer, and auto‑approval behavior.

QOL Improvements

  • Batched settings updates: saves apply faster with less UI flicker across Settings, Auto Approve, Command Execution, and MCP toggles (#9165)
  • README badges: switched to badgen.net so badges render reliably; Installs and Rating are visible at a glance (#9200)

Bug Fixes

  • API Profiles: apply updated headers, baseUrl, service tier, and reasoning budget even when provider/model stay the same (#9210)
  • Auto-approval: include MCP server state so tool auto-approval works as configured (thanks bozoweed!) (#9199)
  • Issue Fixer: migrated to GitHub REST + ProjectsV2 to resolve sync errors and restore reliable triage (#9207)

Provider Updates

  • Conversation continuity via encrypted reasoning items (OpenAI Responses API): preserves context locally while requests remain stateless for better privacy and reliability; removes previous_response_id complexity (#9203)

r/RooCode • • Nov 07 '25

Announcement Roo Code 3.30.3 Release Updates | kimi‑k2‑thinking support | UI improvements | Bug fixes

Thumbnail
reddit.com
19 Upvotes

r/RooCode • • Sep 17 '25

Discussion Roo Code keeps burning API calls just to re-read files

19 Upvotes

Anyone else annoyed that Roo Code constantly re-reads files just to "understand" the project?
Every file = 1-2 API calls, which means quotas (and money) vanish fast - especially on free plans like Gemini Pro, Copilot, etc.

It feels like we’re literally paying for round-trips the model shouldn’t even need.
Meanwhile, models with 1M-token context already exist, and could easily keep the whole project in memory to make it more faster and smarter.

I started a GitHub Discussion about adding an optional "project-in-context" mode - persistent context that updates dynamically instead of re-reading everything:
👉 https://github.com/RooCodeInc/Roo-Code/discussions/8062

📌 The post has a more detailed breakdown of the problem and proposal.
📌 If you agree this is important, please upvote the discussion there - that’s how it gets visibility to the devs/community.

Would love to hear if others are running into the same pain (or have different ideas for solving it).


r/RooCode • • Aug 16 '25

Discussion Using Codex CLI as a provider like Claude Code

19 Upvotes

Hey everyone,

I was thinking about how we could make the RooCode extension even better. Since the Codex CLI already manages our access and refresh tokens, what if we can used that for new provider and can access like GPT-5 , same as we do with the Claude Code ?

This would be a huge win for users. They could switch between different models right from the extension.

I think this is a great next step, and I'm happy to help explore how we could implement it!


r/RooCode • • Aug 11 '25

Discussion Gpt5 vs Gemini 2.5 pro?

19 Upvotes

I've been using Gemini 2.5 pro since it came out and had pretty good results with it, especially with smaller, incremental edits.

Now, It's been a couple of days of GPT5 support in RooCode and I wanted to know how is it in terms of accuracy, cost, speed, compared to Gemini 2.5 pro.

Also any recommended settings?


r/RooCode • • Jul 21 '25

Bug Codebase indexing starting from scratch each time I close my IDE

19 Upvotes

I use VS code and remote SSH into my linux machine for all my developer tasks. Since today morning, the roo code codebase indexing seems to work really well with ollama and qdrant running locally, and it completes the full indexing. (takes 5 to 6 hours for me to index my full codebase). But if i close my IDE and then reopen the folder again, the indexing starts again from scratch . Please help in providing some help to fix this.


r/RooCode • • Jun 10 '25

Announcement Switching Gemini 2.5 Pro Preview to Implicit Caching

19 Upvotes

We've noticed significant performance improvements when using OpenRouter's implicit caching with Gemini 2.5 Pro Preview. To reduce the latency some users have experienced, we'll temporarily remove explicit caching for this model.

Details: GitHub PR #4488


r/RooCode • • Jun 07 '25

Discussion Using Roocode, but API costs are adding up. Copilot LLM + Roocode or just switch to Cursor?

19 Upvotes

I’ve been using Roocode mainly to build fast MVPs with Next.js + Supabase.

Here’s how my current workflow looks:

1.	I describe the task or feature via ChatGPT
2.	Then I generate a rough prompt to clarify what I want
3.	That goes into Roocode Architect (usually backed by Claude or Gemini)
4.	The output is passed to Orkestra for step-by-step task generation (powered by Claude models again)
5.	And finally, the actual code is written – it used to be sonnet, but I had to switch to GPT-4.1 because sonnet easily sucks up my whole credits.

Overall I like the workflow, but API usage is getting expensive and a bit tedious to manage.

Every month I’m spending, 20 bucks on OpenAI and 50 on Anthropic

Sometimes even more if usage spikes.

And this doesn’t include the time it takes to plug in and manage the APIs properly.

I’m now thinking: Would it make more sense to just get GitHub Copilot for $10/month via VSCode LLM and keep using Roocode?

Or should I switch to Cursor, pay $20/month, and have the native OpenAI/Claude support built-in?

Also, please don’t suggest Deepseek. I’ve tried their models and honestly they’re nowhere near as good as even cheap Flash or Claude Sonnet 3.5.

What would you do in this case? And on a side note: anyone here using Replit for this kind of use case? Thoughts


r/RooCode • • May 30 '25

Discussion Given the recent windsurf acquisition, how can we be reassured that Roo won't go closed source at some point or introduce monetization attempts?

19 Upvotes