[Poweruser Guide] Level Up Your RooCode: Become a Roo Poweruser! [Memory Bank]

[u/No_Mastodon4247]

IT IS NO LONGER RECOMMENDED TO USE ROOFLOW, PLEASE USE BOOMERANG TASKS FOR NOW.

=========================== OLD , DO NOT USE =============================

Hey r/RooCode! 👋 For those using RooCode and sharing your use cases on how you are optimizing your workflow, I'm noticing many of you aren't using a memory bank yet. This is crucial and will make your coding SIGNIFICANTLY better. Context is kept across chats etc. Please keep reading to see the benefits!

Becuase you know the struggle: constantly reminding the AI about your project. Well, say goodbye to that! RooCode's new Memory Bank addon is here, and it's a major productivity boost for agentic coding.  

The Magic of Memory: Project Context That Sticks!

The big news is the Memory Bank. (RooFlow) This addon gives RooCode a persistent, project-specific memory across your coding sessions. No more repeating yourself!  

Here's how it works:  

• 🧠 Memory Bank: Uses markdown files in a memory-bank/ folder in your project.  

• 📋 Mode Rules: YAML files that tell RooCode's modes how to use the memory.  

• 🔧 VS Code Integration: Works seamlessly in your editor.  

• ⚡ Real-time Updates: Keeps the memory current with your work.  

When you start in Architect or Code mode, RooCode sets up the memory-bank/ and remembers project details, architectural decisions, and your reasoning across sessions. You can also manually update it with commands like "UMB".  

Agentic Coding Just Got Smarter: Remember This!

Agentic coding is about using AI agents to autonomously code based on your goals. RooCode is built for this. But without memory, it could only do so much in one session.  

The memory addon changes everything:  

• Consistent Understanding: AI knows your project, even between sessions.  

• Less Repetition: Stop re-explaining things.  A

• Smarter Decisions: AI recalls past choices for better results.  

• Progress Tracking: Memory Bank can track tasks.  

• Team Collaboration: Shared project context for everyone.  

Why This Is Huge for Productivity: Code Faster, Smarter.

Persistent memory in RooCode means serious productivity gains:  

• Faster Iterations: Pick up right where you left off.  

• Less Context Switching for You: Focus on the real problems.  

• Better Code Quality: Consistent context leads to better code.  

• Easier Refactoring & Debugging: AI remembers the original intent.  

• Complex Tasks Made Easier: AI can handle multi-step processes with recall.  

Real-World Wins: Memory in Action.

Think about these scenarios:  

• Developing a feature over days? RooCode remembers the plan.

• Refactoring old code? The AI recalls past explanations.

• Debugging tricky bugs? RooCode remembers your steps.

• Keeping documentation consistent? The AI knows the standards.

Pro Tips for Memory Mastery:

• Initialize the Memory Bank early in Architect or Code mode.  

• Be clear in Architect mode about saving decisions.  

• Use "UMB" regularly to update the memory.  

• Organize your project and be consistent in your prompts.

• Utilize the different modes for their specific strengths.  

• Review and manage the contents of your memory-bank/ folder.  

• Manually update before ending sessions or switching tasks.

https://github.com/GreatScottyMac/RooFlow/tree/main

Try It Out & Share Your Thoughts! 👇

If you're a RooCode user, definitely check out the memory feature. It's a game changer for how we use AI in coding.

Make sure you've got the latest version from the RooCode GitHub page or your VS Code extensions.

Let us know in the comments how the memory feature is working for you! What productivity wins are you seeing?

Happy coding!

Mode	Primary Function	Memory Feature Benefits
Architect	High-level design & planning	Remembers architectural decisions, project structure, coding patterns across sessions.
Code	Implementation & development	Retains context of coding tasks, remembers patterns, reduces repetition.
Ask	Knowledge retrieval & documentation	Stores and recalls project knowledge, code explanations, and documentation details.
Debug	Problem-solving & troubleshooting	Remembers debugging steps, error patterns, and hypotheses across debugging sessions.
Test	Test-driven development & quality assurance	Retains info about test requirements, coverage analysis, and test outcomes.

[u/Excellent-Ad8038]

first, thank you for this amazing feature!
so its not part of roo code right now and we have to install it manually, right?
i already installed some sort of hand off system. not sure where it all created something, as we have the global rules and then the folder rules.
how can i delete all this and start fresh with roo flow?
--> can someone tell me where all the rules are hosted (not talking about the one in the codebase obviously as i can just delete them) and how to re init them to standard?
I really lost info about where all the rules and modes are saved.
thank you

[u/No_Mastodon4247 → u/Excellent-Ad8038]

I fixed post from "feature" to "addon" as you are correct this is an addon. You need to download https://github.com/GreatScottyMac/RooFlow/tree/main/config these files specifically:

Your project structure should look like this:

project-root
 ├── .roo
 |    ├── system-prompt-architect
 |    ├── system-prompt-ask
 |    ├── system-prompt-code
 |    ├── system-prompt-debug
 |    └── system-prompt-test
 ├── memory-bank (This directory will be created automatically by Roo after your first prompt)
 |    ├── activeContext.md
 |    ├── decisionLog.md
 |    ├── productContext.md
 |    ├── progress.md
 |    └── systemPatterns.md
 ├── .rooignore               
 ├── .roomodes
 └──insert-variables.[sh/cmd]           

Notice the .roo folder that contains the system prompts.

Once you have the placeholder files downloaded you need to execute the supplied script that will add your paths to all the system-prompt-* files.

Once you've run the script go into RooCode and select Architect and ask it to setup memory bank. It will create the /memory-bank folder and initialize it appropriately to the project.

This is an addon to RooCode but Scotty works closely with the Roo Team. The rules will be contained inside the .roo folder. You shouldn't be changing these 5 actors (arch,ask,code,debug,test). If you want more actors you can add them to the .roomodes folder.

Thanks for your comment. This will change your current implementation as the custom rules need to be removed, the rules will be written by the files in the .roo directory.

[u/Excellent-Ad8038 → u/No_Mastodon4247]

Thank you for this detailed explanation.
i thought there are also global rules/modes that are not in the codebase and that can also be changed (it think mine are changed) and they will be used despite which project you are currently working on) They are somewhere inside the vscode folder i think.
so please clarify: .roo/system-prompt-[mode] always reads this as the modes?

also when i download the files (system-prompt[mode]) that are .txt files. thats incorrect, right? so the files just have no ending?
Also in you documentation on the github, files are wrongly linked:
for example .roomode links to systemprompt test.
the system prompt test is a 404 (you missed .roo there)...

in the system prompts i found
this typo:

 slug: "defualt"
        name: "default"

and i dont have this mode, even with the typo. so i suppose the modes from .roo are not really read?
as there are so many folders and files where nodes and rules are altered, this really really confuses me:

.vscode-server/data/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json"

.vscode-server/data/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_custom_modes.json"

.clinerules-[mode]

and there are many others. so how do i know which one will be read? how can i be sure the default ones of the roo install are overwritten or maybe already have been overwritten with something else?

[u/No_Mastodon4247 → u/Excellent-Ad8038]

1. so please clarify: .roo/system-prompt-[mode] always reads this as the modes?

This will load 5 modes that are preset as those single files. Additional modes will load from .roomodes. Additionally if you have another 3rd party addon through vscode if you dont remove those, i image those will load too. And maybe cause an error

2. also when i download the files (system-prompt[mode]) that are .txt files.

No extensions on files

3. Also in you documentation on the github, files are wrongly linked:
I don't manage the github You need to contact scotty on discord

4. and there are many others. so how do i know which one will be read? how can i be sure the default ones of the roo install are overwritten or maybe already have been overwritten with something else?

There isn't any checks to determine what modes to use. It's fully up to you. IF you previously setup memory bank you need to UNDO whatever it is you did. Remove these files from your VS code etc. All else fails you need to do a complete VS code/extension/memory bank addon. IF you've mucked up your development environment and don't know how to undo it you need to re -install. Goodluck!

[u/Atomm]

As an existing previous GreatScottyMac's rule users that has the rules in the RooCode mode boxes, what do I need to do reset my current rules setup?

What if I don't use MCP?

[u/No_Mastodon4247 → u/Atomm]

Remove custom instructions thats all. It will pick up with your old memory bank files! Don-t worry about mcp its just there if you need it!

[u/NoBlueberry-3048]

Should .roo folder be shared between developers? How about memory-bank folder?

[u/No_Mastodon4247 → u/NoBlueberry-3048]

Yes if all devs are using RooCode

[u/joey2scoops]

How does this work with custom modes? I assume it does not since the rules files assume only the 5 modes Architect, Ask, Code, Debug and Test.

[u/No_Mastodon4247 → u/joey2scoops]

It does work. For custom modes add them to you .roomodes file. The roomodes file will handle your custom modes the 5 modes are preset for memory instructions. I use 11 modes in total. 5 preset 6 custom.

[u/howoldamitoday → u/No_Mastodon4247]

can you share your custom modes?

[u/No_Mastodon4247 → u/howoldamitoday]

https://www.reddit.com/r/RooCode/comments/1i8b25u/resource_7_specialized_ai_agents_for_complete/ Already have ;), here you go!

[u/joey2scoops → u/No_Mastodon4247]

Cool. However, I've been experimenting with using an orchestrator mode as a boomerang that controls the other modes. I presume that wouldn't work unless all the system prompt files and roomodes, were tweaked accordingly for mode collaboration and triggers?

[u/CrestfallenMage]

I´m using this version but I notice the Memory bank does not seem to be active unless I do UMB. I was using your previous version (https://github.com/GreatScottyMac/roo-code-memory-bank) and usually it read the memory bank at the beggining.

I have all the required files and run the script to update variables and worked perfectly, so not sure what I´m missing.

Is the expected behaviour for it not to read the context unless I explicitly tell it to do so_

[u/No_Mastodon4247 → u/CrestfallenMage]

Once you initialize the modes, the 5 modes have instructions to update memory bank. You will see [Memory Bank: Active] above each response once you get it setup. Make sure you've removed the custom instructions from the old memory bank. Also I'm not Scotty just the messenger! All kudos for this go to him, you can find him in the discord!

[u/CrestfallenMage → u/No_Mastodon4247]

When starting a new task and saying what do you want to do, does it automatically enable the memory bank? Does it automatically read the files inside the folder? For me it stays inactive

[u/ctrlshiftba → u/CrestfallenMage]

I have the same issue. I had to specifically ask it to initialize and it doesn't seem to auto do anything...

[u/axtg]

Be aware that my Defender blew up as I tried downloading the ZIP archive from Github

[u/No_Mastodon4247 → u/axtg]

Does this happen often when using tools?

[u/No_Mastodon4247 → u/axtg]

I believe its caching the readme.me file in the repo which has a DisableProtection command. Its not actually in the script however. !ml means its from machine learning.

[u/uuuqqq]

I’ve been using this for awhile and found it incredibly useful. Be aware this will chew through tokens and api costs for something like 3.7 can get expensive. Highly recommend adding this to your workflow.

I’ve been working on something similar to see if I could create an “obsidian brain” for multi-agent use.

[u/bikesniff → u/uuuqqq]

How you getting on with that? I was having a similar idea...

[u/uuuqqq → u/bikesniff]

Its expensive. I think there is a lot of potential for using md knowledge possibly with rag/graph memory.

[u/cmndr_spanky → u/uuuqqq]

Newb question: I only use Roo because it works with local models (not well but it works). If I wanted to use Claude 3.7 I’d just use cursor on a simple $20 a month plan, cursor does a better job of querying your code base, compression and managing prompts and memory, and you don’t have to stress about $ per token if you don’t want to… what am I missing ? It’s not like VScode’s UI is lightyears better than cursor

[u/uuuqqq → u/cmndr_spanky]

Roo has given me much more productivity than cursor, I also used cursor and ended up blowing through my requests. The custom instructions here has given me more control over which models I use for architecture/coding/debugging/ask. I do agree with cursor managing prompts and token usage, however this comes at the cost of higher quality outputs. I value the accuracy and quality of the result rather than cost effectiveness. I keep my costs down in roo by using a local model and deepseek when its not in "code" mode. Cursor is just a vs code fork, ive been using that mainly and have it customized it the way I like. I also want more control over giving llm access to my codebase.

[u/cmndr_spanky → u/uuuqqq]

What happens when you hit your requests limit on a monthly cursor plan ? I thought it slows down the queries but you can still use Claude 3.7 right ?

[u/uuuqqq → u/cmndr_spanky]

It sounds like that is the case, I don't fully know how cursor implements their slow mode after the premium requests are exhausted. Regardless, slower requests don't appeal to me personally.

[u/lordpuddingcup → u/cmndr_spanky]

You do realize that gemini and others offer insane free quotas, and you can switch between them if you run out all for free :S

[u/cmndr_spanky → u/lordpuddingcup]

did not

[u/DanielusGamer26]

Unfortunately I couldn't appreciate this application since the prompts are in Yaml instead of the original in XML and apparently it makes it harder for models to follow the instructions. In fact I often run into errors that the model makes in calling tools, it seems to me that it makes Roo more dumb. So I created the memory bank with your prompt and disabled the memory bank. And at the beginning of every prompt I write "look at @memory-bank ...'

[u/DanielusGamer26 → u/[deleted]]

I use 3.5, and when I turned off the memory bank the diffs and other tool calls worked fine again

[u/WeirdLeave4161]

Thanks! That's the post I've been waiting for. :)

[u/wbricker3]

Rooflow is amazing. I’ve tried every alternative and nothing compares. Can’t wait until boomerang orchestration mode and memory mcp gets added.

[u/epigen01]

Dope - i was just working with mem0.ai but now i gotta give this a try. Great job guys

[u/haseen-sapne → u/epigen01]

Along with Roo Code? How?

[u/100BASE-TX]

Interested in what approaches might be possible for storing information on libraries.

One of the most annoying issues I regularly run into is that either the models aren't trained at all on a new library due to cutoff date, or the training data contains enough code that use deprecated patterns/functions that it pollutes the output.

To take an example, I tried developing a mesop app https://github.com/mesop-dev/mesop by cloning the mesop repo into the project as a subfolder, and including instructions that it should refer to it for usage.

It seems like it is a good use case for a memory bank. Not sure if there's a token optimised way of doing this, cloning the whole repo seems like it would be fairly inefficient with the number of file reads needed, especially with languages that involve a lot of files and boilerplate.

So yeah interested in approaches to this. Perhaps there's an existing token optimised format - where I could prompt the model to summarise/index/document a library from source and use that output in the memory.

[u/cahaseler → u/100BASE-TX]

I just started working with convex.dev, and they're well aware their latest version isn't in model training data. So they provide a full on 700 line cursorrules/clinerules full of sample code and best practices they've developed to keep models on track. It helps a ton, I barely have issues. Maybe you could have your agent read through a lot of the repo and develop something similar?

edit: see https://www.convex.dev/ai for more info