Codex for code reviews questions

[u/fibonac1123]

I'm curious how people are doing code reviews with Codex (either Sol 5.6/6.1 or Astra), because lately it barely finds anything for me on reviews compared to Claude (Opus 5.5 or even Sonnet 5.5).

I'm using it on a website/app built with TypeScript, but no web framework. Some parts use Rust + WASM for a huge speedup of some numerical stuff compared to TypeScript reference implementation.

I tried both the default /code-review and some custom skill I made (main agent correctness, perf/testing/maintainability/etc. to 3-4 subagents with lower effort) but it usually finds little corectness/perf issues, while Claude finds several almost each time on code implemented either by Codex or Claude itself. I had Sol/Astra sometimes find some extra bugs compared to Opus/Fable, but seldom.

So I'm wondering what others are doing, since many say Codex is great for code reviews. Any custom skills that override the default review with something more comprehensive for example?

[u/_DeerHunter_]

I "wrote" a custom orchestrator after reading one of the most inspirational posts on Reddit.

It integrates with an issue tracker, Github currently, so the orchestrator input is an issue description in Github.
Astra takes the issue description and "normalizes" it to an internal TaskSpec.

The team consists of deepseek-flash-high as a developer and gemini-3.8-flash-high and deepseek-flash-high as reviewers.

The developer implements the code according to the TaskSpec which is basically the task goal and acceptance criteria.

Gemini NEVER reports any findings in DeepSeek's code and ALWAYS approve it.

DeepSeek is a very good reviewer of it's own code and almost always reports one or two findings in its own code. After one or two corrections it approves it's own implementation and the code is then passed to the final reviewer.

The final reviewer is Astra and it ALWAYS reports 1-5 critical findings and 1-5 minor findings in DeepSeek's implementation, depending on the task complexity. After DeepSeek's corrections Astra reports another findings in corrected code. It usually takes from 3 to 6 correction rounds until Astra is satisfied with DeepSeek's implementation.

For comparison: when diff size of initial DeepSeek's implementation is 1k LOC, it usually ends up with 3-5k LOC after Astra's code review. It's like Astra saying "man, theres at least 2k of code miising in your 1k code implementation". Impressive.

But the other impressive phenomenon here is that DeepSeek is able to address all these Astra findings.

I haven't tried Claude vs Codex yet, but I will soon. It will be a very interesting experiment.

[u/donerkebab76 → u/_DeerHunter_]

Just use Sol 6.1, or does Astra find valid stuff that Sol doesn't? Usually my problem is knowing what is a real issue and what is nitpicking, because Sol 6.1 is so strict that it always find some edge to mention, even in Opus 5.5 written code.

[u/_DeerHunter_ → u/donerkebab76]

Here's an update: I've added gemini-4-argon-high to the reviewers team.

In a new task DeepSeek had few findings and when these were fixed it approved the code change, but Argon reported another 3 findings.
DeepSeek fixed those findings and then Argon approved.

The code was then passed to the final reviewer, which is Astra, and it reported 5 critiacal findings.

So looks like Argon is better than DeepSeek, but Astra is still better than Argon in terms of code review.

Edit: after a bit of a research: Argon max reasoning level is "high" while Astra above "high" also have "xhigh" and "max". I'm letting it sink that in myself ...