CloudAEye+Codex

Build with Codex. Ship with context.

A second perspective on every change. Review code, check requirements,
and understand the impact, without leaving your Codex workflow.

Get the Codex plugin Explore the workflows

For Codex CLI and desktop Your workflow. Your decisions.

Codex / payments-service
src/payments/retry.ts+8 −2
12 async function retryPayment(id) {13   const payment = await getPayment(id);14 + if (payment.status !== paid) {15 +   await charge(payment);16 +   await markPaid(id);17   }18 }
Catch the issue before it becomes a pull request.
$cloudaeye:inspect
A retry can charge the customer twice.

Two requests can both read an unpaid status before either updates it. The check and the charge are not atomic.

Highretry.ts:14–16Concurrency

Next step Plan an idempotency guard and a concurrent-retry test.

CloudAEye reviews. You decide what changes.

Connected to the work behind your code.

GitHubGitLabBitbucketJira

More context.
At every step.

From understanding an unfamiliar issue to bringing in the right reviewer, make CloudAEye part of the work. Not another place to check.

  1. Understand the task
    before you build.

    Connect the issue to the code it touches. Find the relevant components, current behavior, and people who know it.

    Start with issue context

  2. Challenge the change
    as you build.

    Inspect the diff, check security and acceptance criteria, then turn selected findings into a fix plan.

    See the review workflow

  3. Make an informed call
    before you merge.

    Check PR quality, assess risk, and recommend reviewers. Developers choose the people, accept the suggestions, and decide what ships.

    Find the right reviewers

What are you
working on?

Twenty ways to bring deeper review and better decisions into your Codex workflow. Find the work; the right command follows.

ReviewReview AI-generated code before the PR

Catch bugs, missed edge cases, concurrency problems, and invalid inputs with Inspect. Run Security for application and AI-integration vulnerabilities, or Review for all six report types.

$cloudaeye:inspect$cloudaeye:security$cloudaeye:review
ReviewCheck the implementation against the task

Validate pending changes against a Jira ticket, GitHub issue, or written specification. Identify missing requirements and incomplete acceptance criteria before opening a PR.

$cloudaeye:check-task
UnderstandSee the impact beyond the diff

Visualize changes to function calls and execution paths. Inspect system architecture, repository layers, dependencies, affected callers, and potential downstream risks.

$cloudaeye:control-flow$cloudaeye:review-arch
ReviewKnow where human review matters most

Assess PR risk using bug history, rework, code ownership, author history, and AI slop score. Use the evidence to prioritize limited engineering review capacity.

$cloudaeye:risk-score
CoordinateBring in the right reviewers

Find reviewers with relevant ownership and contribution history, considering their review queues. Add urgency or availability context, then explicitly request reviews from the people you choose.

$cloudaeye:assign-reviewer
ReviewKeep every PR up to your standards

Run the repository's configured checklist for documentation, tests, README freshness, dependencies, PR metadata, duplicate code, and potential secrets. Read the detailed report on the PR before merging.

$cloudaeye:check
ReviewFind AI-generated code worth a closer look

Assess nine quality signals, including duplication, nonexistent APIs, dead code, missing tests, and overengineering. Use the findings, not just the score, to guide manual review and refactoring.

$cloudaeye:slop-score
ImproveFill the documentation gaps

Generate docstring suggestions for undocumented code in an open PR. Review the proposed documentation and choose which suggestions to accept.

$cloudaeye:add-docs
ImproveGive new code the tests it needs

Generate unit-test suggestions for uncovered code in an open PR, including new test files when needed. Review and run those tests before accepting them.

$cloudaeye:add-tests
ImproveTurn a finding into a fix plan

Convert selected review findings into a structured plan. Understand which files and callers are affected, and which related defects or tests belong in the fix.

$cloudaeye:implement
CoordinateMake follow-up work actionable

Create Jira tickets or GitHub issues from selected findings, with assignees and context. Identify findings already tracked in the same session to reduce duplicate work.

$cloudaeye:create-issue
UnderstandUnderstand an issue before writing code

Connect a Jira or GitHub issue to the code it affects. Understand relevant components, current behavior, and surrounding implementation before changing an unfamiliar codebase.

$cloudaeye:explain
UnderstandGive your changes a clear description

Generate a Markdown PR description or commit message from pending changes. Summarize the important modifications and their cross-file impact for teammates.

$cloudaeye:describe
CoordinateEstablish who knows the code

Generate OWNERS.md files from Git history. Identify the developers contributing to each part of the repository and create an ownership starting point your team can refine.

$cloudaeye:create-owners
CoordinateGet your repository ready for review

Detect the provider, remote URL, and base branch. Configure the monitor branch and complete integration setup when requested.

$cloudaeye:init
UnderstandFind the command you need

Explore the command catalog, arguments, options, and usage examples without memorizing the plugin interface.

$cloudaeye:help
ReviewGive a high-risk change a complete review

Combine correctness and security review with control flow, architecture, and requirement validation. Follow with risk scoring and reviewer recommendations to focus the human review.

$cloudaeye:review$cloudaeye:control-flow$cloudaeye:review-arch$cloudaeye:check-task$cloudaeye:risk-score$cloudaeye:assign-reviewer
CoordinateKeep developers in control of AI work

Connect implementation, validation, and review. Inspect changes, check requirements, propose tests and documentation, assess risk, and recommend reviewers. Developers accept suggestions, request reviews, and decide whether to merge.

Build your workflow
CoordinatePrioritize the PRs that move work forward

Triage PRs by business impact, complexity, and risk. Give higher-value work tied to your organization's OKRs the attention it deserves.

$cloudaeye:triage-prs
Explore PR triage
UnderstandMake a large pull request explainable

Organize a large diff into logical groups of work with PR walkthrough. Understand dependencies between groups and highlight potential risks and architectural impacts.

Explore PR walkthrough

In Codex, select skills with $cloudaeye:. Available commands depend on your installed plugin version.

Read the Codex guide

Your next change.
A better second look.

Install the plugin, connect CloudAEye, and start in the repository you're already working on.

Open the setup guide Talk to our team
  1. 1

    Install the CloudAEye plugin

    Use a current Codex CLI with plugin support. Run in your terminal, then restart Codex.

    codex plugin marketplace add CloudAEye/claude-plugin
codex plugin add cloudaeye@cloudaeye
codex plugin list
  2. 2

    Connect your CloudAEye account

    Complete CloudAEye authentication in the plugin's setup prompt. The plugin supplies its MCP connection.

  3. 3

    Open a repository. Start a review.

    Start a new Codex chat, run $cloudaeye:init, then $cloudaeye:inspect.

A few things worth knowing.

Does this work before I open a pull request?

Yes. Inspect, Security, and Review can analyze pending changes. Commands such as Add Tests and Add Docs work on an open PR. Use the command help to check the scope for your task.

Why do these commands begin with a dollar sign?

Codex selects installed skills with $, for example $cloudaeye:inspect. Claude Code uses slash commands. See the official CloudAEye Codex guide for the current setup and invocation details.

Does CloudAEye accept suggestions or merge for me?

These workflows keep decisions with the developer. Review findings and generated suggestions, run proposed tests, choose which changes to accept, and explicitly request reviews from your selected reviewers.

What do I need to get started?

A Git repository, CloudAEye account with Code Review access, and an activated Codex account with available usage. Follow the documented prerequisites and Codex setup guide for tooling and authentication.