Running multiple composers at the same time

Hello, everyone.
I’m a cursor fanatic.
I think I’m pretty good with cursor, what’s it called, ON FIRE?
I’m trying to run as many composers as I can on a project at the same time.
Like in the picture
I’ve set up my own set of rules and cursorrules and prompt methods for AI, if anyone is interested I can summarize it in a document and share it here.

I’m using translation software to translate
But hopefully I can find someone who is as obsessed with it as I am to exchange ideas.
Translated with DeepL.com (free version)

I did it by copying the workspace from the file setting

1 Like

so you opened all your projects files and docs and cursorrules files, etc and then clicked “save workspace as” button in the file menu. then opened a new instance of vscode and opened that saved file as a workspace, then repeated for a total of 3 composer agents running in the same file…
but, you cant actually run the composer agents simultaneously, right? they would end up trying to edit file… i imagine search and replace tool would give a lot of errors…

but i can see this having some usefulness. i mean, it essentially triples you total conext window, and in theory, you could probably keep going bigger…

anyway, mildly interesting idea, i like it.

Output all information in JSON format wherever possible
Then re-describe it to me in a tree diagram format
The tree structure then gives the location of the root directory where the modified file and the currently read file are located
Any explanations and understandings as well as replies are output in JSON format.
If possible, check the file associated with the change and output it again as an ASCII chart.

DO NOT GIVE ME HIGH LEVEL STUFF, IF I ASK FOR FIX OR EXPLANATION, I WANT ACTUAL CODE OR EXPLANATION!!! I DON'T WANT "Here's how you can blablabla"

Be casual unless otherwise specified
Be terse
Suggest solutions that I didn’t think about—anticipate my needs
Treat me as an expert
Be accurate and thorough
Give the answer immediately. Provide detailed explanations and restate my query in your own words if necessary after giving the answer
Value good arguments over authorities, the source is irrelevant
Consider new technologies and contrarian ideas, not just the conventional wisdom
You may use high levels of speculation or prediction, just flag it for me
No moral lectures
Discuss safety only when it's crucial and non-obvious
If your content policy is an issue, provide the closest acceptable response and explain the content policy issue afterward
Cite sources whenever possible at the end, not inline
No need to mention your knowledge cutoff
No need to disclose you're an AI
Please respect my prettier preferences when you provide code.
Split into multiple responses if one response isn't enough to answer the question.
If I ask for adjustments to code I have provided you, do not repeat all of my code unnecessarily. Instead try to keep the answer brief by giving just a couple lines before/after any changes you make. Multiple code blocks are ok.

These are my cursorrules.
I want cursor to return me as much detail as possible, so I can always understand what he’s trying to do and what he knows, and then make the changes it actually performs as fine-grained as possible.
Of course I’ll include Chinese, hhh
Reply in 中文 when interpreting the code.

Thank you for expressing an interest in this.

This has the first advantage of being able to keep 3 composers with different memories on the same project, (although historical memories would work, but I feel it would be uncomfortable to switch)

Generally speaking, I’ll cut up the tasks according to the modularity idea after the project is configured, and let my composers handle them individually, but we’re required to have a bit of a requirement for each interaction with the composers.
That’s why I made my cursorrules

Of course, one nice use of composer is that after producing an unsatisfactory edit, we can go back to the previous dialogue and use its restore

This is important because it protects our output from being corrupted, and it protects our current composer’s contextual memory from being polluted
I think the memory of the composer is very valuable, because when you let a composer change too many files, it can really give you unsatisfactory output.

With this knowledge, we can have multiple composers working at the same time, each on a different module or page. Often though, it makes me feel like my brain is being emptied by all this AI. hhhh

This is the RESTORE I did when it changed the wrong file and then replied, I think this image is more graphic, the red is the first time, the yellow is what I added the second time, and the blue is what I added the third time.
Then it gives me the changes I want, amazing isn’t it!

i cant read chinese, so none of that means anything to me, unfortunately.

im not sure im following what your describing. yes the composer has checkpoints, we can revert back to any part of the conversation and have our files reverted to the state they were in at the being of the message we have returned too.

are you doing something special that im missing besides having the instances open at once? i mean, i dont really see the benefit there, yeah you can do 3 things at once, but the composers will eventually try to edit the same file. and then more and more errors. how do you prevent this since none of the composers are aware of the others??

1 Like

Okay, here’s the project folder I’m working on
I’ll let composerA read the contents of the ‘files’ folder, or the files that are linked to his internal function calls.
and then use it to manage them.
ComposerB will manage the ‘home’ folder, and composerC will manage the ‘my’ folder.
This is more comfortable than using one composer for all folders, and you can always recall the best previously used composer.

If a single folder is too big, you can probably use composerAa to manage subfolders of a directory.
At the moment, fortunately, they are synchronised on the local folder, so even if composerA modifies a file in some composerB, composerB will see A’s modification and think it is yours!
Even if they do edit to the same file, we should be aware of it ourselves, it’s under control!

I don’t know if this helps, but thanks for being willing to communicate and let me know that my description leaves a lot to be desired!

pages:.
├─file
│ │ file.vue
│ │
│ ├─contract
│ │ detail.vue
│ │ index.vue
│ │ preview.vue
│ │
│ └─receipt
│ detail.vue
│ index.vue
│ supplement.vue

├─home
│ │ home.vue
│ │
│ └─contract
│ │ create.vue
│ │ index.vue
│ │ preview.vue
│ │
│ ├─fill
│ │ index.vue
│ │
│ ├─preview
│ │ contract.vue
│ │ detail.vue
│ │ index.vue
│ │ template.vue
│ │
│ └─sign
│ index.vue
├─my
│ │ my.vue
│ │
│ ├─about
│ │ index.vue
│ │
│ ├─enterprise
│ │ index.vue
│ │
│ ├─feedback
│ │ index.vue
│ │
│ ├─package
│ │ │ index.vue
│ │ │
│ │ └─buy
│ │ index.vue
│ │
│ ├─privacy
│ │ index.vue
│ │
│ ├─signPassword
│ │ index.vue
│ │ verify.vue
│ │
│ ├─userAgreement
│ │ index.vue
│ │
│ └─wechat
│ index.vue

├─pay
│ index.vue

Is this why the slow pool is 5 min waits now

6 Likes

interesting concept. I guess it depends what kind of project it is and how much folder A rely’s on folder B’s contents