Back to database

Daniel Roth, LinkedIn's AI use case

Editor in chief / product builder at LinkedIn

Uses a dual-agent app-building workflow where one AI agent acts as the builder and another acts as the reviewer, helping a non-traditional developer move faster while keeping a second layer of critique on the work.

The problem

What was broken before AI

AI coding tools make it easier to start building, but they can also create a false sense of confidence. A single model may produce code that looks plausible, runs for the demo, and still has bugs, edge cases, or design issues hiding underneath. For a non-specialist builder, the challenge is not only getting code written. It is knowing whether the code is good enough to keep using.

What changed

What the use case made possible

Daniel’s workflow creates two AI roles. The builder agent focuses on turning the product idea into working code. The reviewer agent inspects the output, points out problems, and suggests fixes. That gives the human a more useful conversation: not just “here is the app,” but “here is what was built, here is what might be wrong, and here is what to check before moving forward.”

Why this matters

Why this use case is worth studying

Daniel’s use case is useful because it borrows a familiar software practice — build and review — and applies it to AI-assisted work. The second agent does not remove the need for human judgment, but it changes the quality of the review. It gives the builder another perspective before they commit to the output, which is especially valuable when the human is learning as they go.

Use this when

When this pattern applies

Use this pattern when you are building with AI but do not fully trust the first version. It works especially well for small apps, prototypes, internal tools, or features where the output is easy to inspect but still needs a second perspective before you keep building on top of it.

Exponential Builder analysis

01

Split creation from judgment.

AI-assisted building gets safer when the model that generates the first pass is separate from the model asked to critique it; the role separation creates friction at exactly the point where plausible output can be mistaken for finished work.

02

Keep the unit of work reviewable.

The workflow depends on small, testable features with clear expected behavior, because a reviewer agent can only be useful when the human can inspect whether its critique maps to reality.

03

Treat critique as input, not instruction.

The reviewer’s notes are a second perspective for the human to filter, which keeps the builder in control of product judgment instead of turning model confidence into an approval process.

Who this is for

Best fit

Non-engineers building with AI coding tools

Product managers prototyping apps

Founders building early product ideas

Engineers using AI on unfamiliar code

Designers or editors experimenting with software

Anyone who wants an AI build loop with more critique built in

What to avoid

Mistakes and warnings

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

Do not let one agent be both creator and final judge.

Avoid building features too large to inspect.

Do not accept every review note just because it sounds authoritative.

Keep prompts focused on behavior and testability, not just code changes.

Remember that a second AI review is useful, but it is not the same as real user testing.

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 a narrow job

The first agent focuses on turning a specific product idea into a working first version.

02

Keep the task small enough to inspect

The workflow works best when the app or feature has clear behavior that can be tested.

03

Send the output to a reviewer

A second agent reviews the code, UX, edge cases, and likely failure points.

04

Use critique as the next prompt

The human chooses which review notes matter and sends the useful ones back into the build loop.

05

Keep humans responsible for acceptance

The final decision is not delegated to either model; the person building still tests, chooses, and ships.

Copy the pattern

The reusable idea

Pattern in one sentence

Use one AI agent to build and another to review, so creation and critique happen as separate steps before a human decides what to keep.

Reusable idea

Daniel’s workflow is a good reminder that AI does not have to be one assistant doing everything. When a task involves both creation and judgment, split those jobs. Let one model generate a first pass, then ask another to criticize it from a different angle. The useful part is not the extra complexity. It is the pause between “it works” and “it is good enough.”

Steal this workflow

Dual-agent build loop for a small app feature:

1

Define one feature in plain language: what the user should be able to do, what should happen, and what counts as done.

2

Builder pass: ask the first agent to build the smallest working version, keep the code simple, list changed files, and explain how to test it.

3

Human check: run or inspect the result before asking for more changes; write down what actually works and what feels unclear.

4

Reviewer pass: give the implementation, expected behavior, and your notes to a second agent. Ask it to find bugs, missed requirements, edge cases, confusing UX, fragile assumptions, and unnecessary complexity.

5

Human triage: sort review notes into three buckets: fix now, ignore, investigate manually.

6

Builder iteration: send only the “fix now” items back to the builder and ask for the smallest necessary changes.

7

Final gate: manually test the feature again before treating it as ready for real users.

Suggested prompt

“Review this implementation as a strict senior engineer and product-minded tester. The feature is: [describe the feature]. Expected behavior: [describe what should happen]. Here is the implementation or changed files: [paste code or summary]. Look for bugs, missed requirements, edge cases, confusing UX, fragile assumptions, and code that is more complex than needed. For each issue, explain why it matters, how severe it is, and the smallest practical fix. Do not rewrite the code yet; give me a prioritized review I can decide from.”

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