Philosopical and practical difference between "/architect" vs "/ask /code" workflow

[Xparx]

Issue

I'm learning how to work with aider. I have gone through the documentation that I could find.
I am unclear of the beneficial difference between using the /architect workflow vs just using the /ask /code workflow.

The difference I can see is that /architect uses two models even though the synergy sometimes seems lacking. Doing reasoning with one and implementation with the other.

But the idea behind /architect is that a model first does a round of reasoning and then passes on that finished context to the editor model.
Which sound to me very similar to the /ask /code approach.
If there is any deeper diving documentation on this difference.

I have seen the benchmark in the documentation that would indicate that sometimes for some combination of models the performance is increased. But I would guess that a similar benchmark could be done for the
/ask then /code approach?

The downside of the /architect approach is that the combinatorial uncertainty is large enough that it's hard to be convinced in practice that it is working.

I ran some minor test for myself to see, comparing the suggested optimal model in the benchmark in the documentation for /architect and just picked the opus-4.6 model with high reasoning for /ask /code. I'm not sure if this is an unfair comparison but I think the funds spent on the two approach are similar even though the models in the architect setup are much cheaper...

Anyway. Any additional documentations or thoughts on how to work with this would be appreciated. Or if there is some way where I can compare apples to apples when trying to figure out how to work.

Thanks for aider. It is so far been a pleasure to work with!

Version and model info

aider 0.86.2
reasoning = high

• /architect deepseek/diff --- o4 reasoning
• /code /ask opus-4.6

[1Ckpwee]

I've been wondering about this too. From my testing, the key difference is that /architect keeps the reasoning context tightly coupled with the edit pass — the architect model's output gets fed directly into the editor model as structured instructions. With /ask then /code, you're manually bridging that gap and the context from /ask gets mixed into the general chat history.

In practice I've found /architect works better for larger refactors where the reasoning needs to stay focused, while /ask + /code gives me more control when I want to steer the reasoning before committing to edits. Would love to see benchmarks comparing the two approaches more formally though.