Back to database

CJ Hess's AI use case

Engineer / builder at To verify

Uses a model-vs-model development workflow where one AI agent builds the first version and another reviews the output for bugs, edge cases, production readiness, and missed requirements.

The problem

What was broken before AI

AI coding tools can create working-looking software quickly, but the first version is often uneven. It may pass a simple demo while missing edge cases, producing brittle code, or misunderstanding a requirement. A human can review the work, but when the builder is moving fast or working outside their strongest area, it is easy to miss issues that another reviewer would catch.

What changed

What the use case made possible

CJ’s workflow separates the roles. The first model acts as the builder and focuses on creating the implementation. The second model acts as a reviewer and focuses on finding problems. The reviewer’s output becomes the next input for the builder, but the human stays in charge of deciding which critiques are valid. That separation makes the workflow feel closer to a lightweight engineering team than a single chat session.

Why this matters

Why this use case is worth studying

This use case is valuable because it brings a familiar engineering habit into AI-assisted coding: do not let the author be the only reviewer. The second model is not a perfect senior engineer, but it can create friction at the right moment. It forces the work to survive another perspective before the human accepts it.

Use this when

When this pattern applies

Use this pattern when AI-generated code looks promising but you do not fully trust the first version. It works especially well for small features, prototypes, internal tools, or unfamiliar code where a second perspective could catch issues before you keep building.

Exponential Builder analysis

01

Split generation from judgment.

AI coding works better when the same assistant is not responsible for both producing the answer and grading it. Assigning a second model to critique creates useful resistance before the human gets attached to the first draft.

02

Treat critique as input, not instruction.

The reviewer model can surface bugs, edge cases, and missed requirements, but its notes still need a human filter. The value comes from turning good objections into the next build pass while ignoring speculative rewrites.

03

Keep the loop small enough to inspect.

This workflow is strongest on bounded features, fixes, and prototypes where the requirements, diff, and expected behavior can fit in one review context. If the task is too broad, both the builder and reviewer can drift into confident but shallow feedback.

Who this is for

Best fit

Developers using AI coding tools

Founders building prototypes

PMs or designers vibe-coding small tools

Engineers working in unfamiliar codebases

Teams trying to improve AI-generated code quality

Anyone who wants critique before accepting a model’s first pass

What to avoid

Mistakes and warnings

Where this pattern can go wrong if you copy it too literally.

Do not assume the reviewer model is always right.

Avoid sending vague requirements into the build step.

Do not let the second model create an endless list of speculative issues.

Keep the task small enough that both models and humans can inspect it.

Remember that model review is useful, but it does not replace real tests or users.

Public workflow preview

The shape of the workflow

A high-level look at how the use case works, with the reusable pattern made clear.

01

Give the builder model a clear task

The first model gets the feature, constraints, and expected behavior.

02

Create a first-pass implementation

The builder produces code, tests, or a working prototype.

03

Send the output to a reviewer model

A second model inspects the work for bugs, missed requirements, edge cases, and risky assumptions.

04

Turn critique into the next build pass

The human chooses useful feedback and sends it back into the build loop.

05

Keep final approval human

The model review improves the work, but the human still tests and decides what is good enough.

Copy the pattern

The reusable idea

Pattern in one sentence

Use one model to build and another model to review, so the work has to survive a second perspective before a human accepts it.

Reusable idea

CJ’s workflow is a reminder that AI coding gets better when the model is not asked to be both maker and judge. If a task matters, split the work into two passes: build, then review. The critique does not need to be perfect to be useful. It just needs to surface questions you might not have asked before shipping.

Steal this workflow

Use a two-model review loop for any coding task that matters:

1

Write one clear requirement: expected behavior, constraints, and known edge cases.

2

Ask Model A to build the smallest working implementation and explain the files changed.

3

Run or inspect the result before sending it anywhere else.

4

Paste the requirements, code/diff, and expected behavior into Model B.

5

Ask Model B only to review: bugs, missed requirements, edge cases, unclear logic, risky assumptions, and production-readiness issues.

6

As the human, sort the critique into three buckets: must fix, maybe later, ignore.

7

Send only the must-fix items back to Model A.

8

Repeat once or twice, then stop and run real tests or manual checks.

9

Keep final approval with the human, especially when the reviewer suggests broad rewrites.

Suggested prompt

"You are reviewing this implementation against the original requirements. Do not rewrite the code yet. Identify bugs, missed requirements, edge cases, unclear logic, risky assumptions, and production-readiness issues. For each issue, explain why it matters, what evidence you see in the code or behavior, and whether it is high, medium, or low priority. Separate concrete problems from speculative improvements. Here are the requirements, expected behavior, known edge cases, and implementation: [paste details]."

Field notes

Get new AI use cases in your inbox

A short weekly note on how real people are using AI to save time, make money, build tools, and run their lives.

No spam. Just useful AI use cases.

Related use cases

Keep exploring nearby systems.

Browse all