Post-Dev Run Workflow: The Complete Guide from PR Review to Merge

Introduction

After pressing the Dev Run button and waiting a while, the job completes. But this is where the real work begins. Dev Run completion means "the AI has finished writing code," not "the code is ready for production."

After Dev Run, there is a series of steps: checking the evaluation result, reviewing the PR, executing Finalize, and merging. Understanding this process lets you safely and efficiently ship AI-generated code to production.

This article provides a comprehensive guide to the post-Dev Run workflow, making clear what to do at each step.

Overall Flow

The post-Dev Run workflow follows this flow:

Loading diagram...

Let's walk through each step in detail.

Step 1: Check the Evaluation Result

When Dev Run completes, the AI performs a quality assessment in Phase 10 (Evaluation). Start by checking this result.

Three Evaluation Results

Result	Meaning	Recommended Action
PASS	All requirements met	Proceed to PR review
PASS WITH ISSUES	Requirements met but issues exist	Review issues before deciding
FAIL	Requirements not met	Analyze cause and re-run

When PASS

This is the ideal outcome. The AI has completed an implementation that meets all requirements. Proceed to the next step: PR review.

However, PASS means "no issues in the AI's judgment," not "human review is unnecessary." Always verify code quality, architectural alignment, and business logic correctness with human eyes.

When PASS WITH ISSUES

Requirements are met, but minor issues were detected. Review the issues listed in the evaluation report and decide on a course of action.

Examples of acceptable issues:

• Minor coding style inconsistencies
• Slightly lower test coverage (though main paths are covered)
• Some unnatural phrasing in documentation

Examples of issues requiring fixes:

• Security concerns
• Potential performance impact
• Unexpected side effects on existing functionality

If the issues are acceptable, proceed to PR review. If fixes are needed, consider rollback.

When FAIL

Requirements are not met, so you cannot Finalize directly. Analyze the root cause and take appropriate action.

Common FAIL causes and responses:

Cause	Response
Vague Issue description	Improve the Issue and run a new Dev Run
Tests are failing	Rollback to the problematic phase and re-run
Inappropriate design decisions	Rollback to the design phase
Implementation scope too large	Split the Issue into smaller units

For more on debugging failed jobs, see Debugging Failed Jobs.

Step 2: Review the PR

If the evaluation result is PASS (or an acceptable PASS WITH ISSUES), review the draft PR that the AI created.

Review Process

For an efficient review, follow this recommended sequence:

1. Check the phase reports

Before reading the PR diff, review the phase reports. These four reports are especially important:

• Planning report: Task understanding and strategy
• Design report: Architectural decisions
• Testing report: Test results and coverage
• Report phase: Change summary and remaining issues

2. Review the changed file list

Verify that no unexpected files were changed and that no changes are missing.

3. Review the code diff

Using the context gained from the phase reports, examine the actual code.

Review Checklist

Category	Check Item
Requirements	Does the implementation meet all Issue requirements?
Design	Is it consistent with the existing architecture?
Code Quality	Does it follow coding conventions?
Security	No hardcoded secrets, no injection risks?
Tests	Are tests sufficient and all passing?
Documentation	Has documentation been updated to match changes?
Impact	No unintended effects on existing functionality?

For review techniques specific to AI-generated PRs, see Tips for Reviewing AI-Generated PRs.

Step 3: Decide How to Handle Issues

If you find problems during review, decide on a response based on severity.

Decision Flow for Issue Response

Loading diagram...

Comparison of Response Options

Option	Best For	Steps
Manual fix	1-2 minor corrections	Commit directly to the draft PR branch
Rollback	A specific phase made a wrong decision	Rollback to that phase and re-run
Revise Issue	Fundamental issue with the Issue description	Rewrite the Issue and start a new Dev Run
Abort	Need to change direction entirely	Abort or close the PR
Follow-up Issue	Problem outside current scope	Finalize current PR, address in a separate Issue

Tips for Manual Fixes

When adding manual commits to the draft PR branch, keep these points in mind:

• Understand that Finalize will reorganize commits
• Record your manual changes in a PR comment
• If extensive manual fixes are needed, consider rollback or re-run instead

Step 4: Execute Finalize

Once review is complete and you've determined the code is merge-ready, execute Finalize.

What Finalize Does

1. Commit cleanup - Multiple phase commits are consolidated into clean commits
2. PR publication - The draft PR is converted to a public PR
3. PR description - The Report phase output is set as the PR description

Finalize Requirements

Condition	Description
Dev Run is complete	All phases have finished
Evaluation is PASS or PASS WITH ISSUES	FAIL cannot be Finalized
Not yet Finalized	Prevents double execution

For detailed Finalize instructions, see How to Use Finalize.

Step 5: Merge

After Finalize completes, merge the public PR.

Pre-Merge Checklist

• CI/CD pipeline: All checks are passing
• Conflicts: No merge conflicts exist
• Team review: The PR has passed your team's review process

Choosing a Merge Method

Method	Characteristics	Recommended For
Squash and Merge	Combines into 1 commit	Solo development, simple changes
Merge Commit	Preserves full history	Team development, detailed history needed
Rebase and Merge	Creates linear history	Keeping history clean

Since Finalize already cleans up commits, Squash and Merge is often the cleanest choice.

Post-Merge Actions

After merging, verify the following:

• CI/CD pipeline completion (if auto-deploy is configured)
• Production environment verification (as needed)
• Closing related Issues
• Preparing the next Dev Run if follow-up Issues exist

Step 6: Follow Up

Reflecting on the Dev Run results and applying lessons learned to next time is also important.

Creating Follow-up Issues

Issues identified during review as "out of scope for this PR but needs attention" should be created as follow-up Issues.

Examples of follow-up Issues:

• Fixing minor issues flagged in PASS WITH ISSUES
• Improving test coverage
• Performance optimization
• Additional documentation

You can also use DevLoop Runner's Auto Issue Creation feature to efficiently create follow-up Issues.

Reflecting on the Issue

Based on the Dev Run results, reflect on how the Issue was written.

Dev Run Outcome	Improvement Hint
Planning report was vague	Add specific requirements and expected behavior to the Issue
Design direction was wrong	Add technical constraints and references to existing design
Insufficient tests	Specify testing perspectives and quality criteria in the Issue
Scope was too large	Split the Issue to keep each one small and focused

For more on writing effective Issues, see GitHub Issue Writing Guide.

Situation-Based Quick Reference

Here's a summary of common post-Dev Run situations and how to handle them.

"Perfect result"

1. Confirm PASS evaluation
2. Quickly review phase reports
3. Review the PR diff
4. Execute Finalize
5. Merge after CI/CD passes

"Mostly good but minor issues"

1. Review PASS WITH ISSUES details
2. If acceptable, proceed to PR review
3. Add manual fixes to the branch if needed
4. Execute Finalize
5. Create follow-up Issues

"Need to redo"

1. Identify the problematic phase
2. Rollback to that phase
3. Provide specific reasons if using manual mode
4. Wait for re-execution
5. Review results again

"Need a fundamentally different approach"

1. Reconsider the Issue content
2. Abort the job if needed
3. Rewrite the Issue (or use Rewrite Issue to let AI improve it)
4. Start a new Dev Run

Summary

• Dev Run completion means "AI work is done," but human review and Finalize are required
• The evaluation result (PASS / PASS WITH ISSUES / FAIL) determines the next action to take
• Checking phase reports before PR review enables efficient and focused reviews
• When issues are found, choose between manual fix, rollback, or re-run based on severity
• Finalize converts the draft PR to a public PR, enabling merge
• Reflecting on results and improving Issue quality enhances the next Dev Run

Dev Run is not "fire and forget." By carefully following the post-completion workflow, you can maximize the quality of AI-generated code and safely ship it to production.