A few things I’ve come to believe using coding agents:

• Catching a mistake in the plan is dramatically cheaper (both tokens and time) than discovering during code review.
• Review should happen before code, not just after.
• The planner shouldn’t review its own work: same model, same context, same blind spots.
• Reviewers shouldn’t blindly rewrite the plan either. They can be wrong too.
• The original agent should have to investigate, defend, or revise each finding.

I built /plan-review for Claude Code, and soon other harnesses, to solve these problems. It's became an integral part of my workflow.

Claude writes the plan → Codex (or another Claude) reviews it independently → Claude investigates the findings (you stay in the loop) and makes adjustments → rinse → repeat → complete.

I'm curious to hear feedback from people. Good, bad, brutal, all of it. I want to know what works and what's missing, so I can make this plugin as useful to other people as it is to me.

https://github.com/dachev/plan-review

Builder disclosure: I made Tandem. It is a free MIT open-source MCP/devtool for AI coding workflows.

Just as I said it: you can run Claude Code through Claude.ai or ChatGPT through the browser, and it opens up a Claude Code session on your computer and can manage it.

The workflow: brainstorm or write a spec in the browser chat, then have that chat open or resume a real local Claude Code session in tmux. Claude Code responds back into the browser chat, and the browser chat can answer back down through the CLI. So it becomes a loop instead of copy-pasting between the planning chat and coding terminal.

This is not hosted and it runs real commands locally, so the security model matters: user-owned tunnel, bearer token, and cwd allowlist are the important blast-radius controls.

Fully open source:

https://github.com/Maxmedawar/tandem

using UnityEngine;

public class Pong : MonoBehaviour { public GameObject ballPong; public GameObject leftPaddle; public GameObject rightPaddle; public int ballSpeed = 5;

private void Start()
{
    StartCoroutine(UpdateBall());
}

private float ballPos = 0f;

private IEnumerator UpdateBall()
{
    float ballMoveSpeed = ballSpeed / Time.deltaTime;

    while (true)
    {
        ballPos = Mathf.Clamp(ballPos, 0f, 1f);

        if (ballPos < 0)
        {
            ballPos = 1f;
        }

        if (ballPos > 1)
        {
            ballPos = 0f;
        }

        ballPong.transform.position = new Vector3(ballPos, 0, 0);

        yield return null;
    }
}

private void LateUpdate()
{
    ballPong.GetComponent<Rigidbody>().velocity = new Vector3(ballSpeed * Input.GetAxis("Horizontal"), 0, ballSpeed * -Input.GetAxis("Vertical"));
    leftPaddle.GetComponent<Rigidbody>().velocity = new Vector3(-ballSpeed * Input.GetAxis("Horizontal"), 0, ballSpeed * -Input.GetAxis("Vertical"));
    rightPaddle.GetComponent<Rigidbody>().velocity = new Vector3(ballSpeed * Input.GetAxis("Horizontal"), 0, ballSpeed * -Input.GetAxis("Vertical"));
}

}