Reading
A methodology to improve the quality of AI-generated code by splitting tasks into small, reviewable code chunks and using a planned branch stacking strategy to reduce code review difficulty and defects.
Section 01
This article introduces a methodology to improve the quality of AI-generated code: Agentic Coding Workflow. By splitting tasks into small, reviewable code chunks and using a planned branch stacking strategy, this method reduces code review difficulty and defects, aiming to solve the challenges of code review in the AI programming era.
Section 02
With the popularity of AI programming tools like GitHub Copilot and Cursor, developers' code generation speed has increased significantly. However, this also brings a new problem: AI-generated code changes are often large in volume and dense in logic, posing great challenges to code review.
The traditional code review process assumes that the PR submitted by developers is the result of careful consideration, but AI-assisted programming changes this premise. Developers may generate hundreds of lines of code in a short time, which may hide AI "hallucinations", missing boundary conditions, or implementations that do not match the existing architecture.
When reviewers face large blocks of AI-generated code, they often feel at a loss—struggling to quickly understand the whole picture while worrying about missing potential issues. This "review fatigue" is becoming a unique pain point in the AI programming era.
Section 03
The core idea of Agentic Coding Workflow is to split large code changes into a series of small, independent, reviewable units. This method draws on the long-standing "small steps" concept in software engineering but is specifically optimized for the characteristics of AI-generated code.
Plan Before Coding: Before writing any code, create a detailed task breakdown plan. Clarify the boundaries, input/output, and acceptance criteria for each small task.
Single Task per Branch: Each small task is completed on an independent branch to maintain focus. This not only facilitates rollback but also allows reviewers to examine each task one by one.
Branch Stack Organization: New task branches are created based on the previous task's branch, forming a clear dependency chain. Finally, integrate into the main branch via stacked commits or batch merging.
Before starting coding, use tools to generate a FEATURE_PLAN.md document, breaking down the entire feature into atomic tasks. Each task should meet:
Create an independent branch for each task, following the feature/task-name naming convention. During development:
When multiple related tasks pass review, integrate them in a stacked way:
This approach avoids "big bang" merges, making each merge a low-risk small-step operation.
Section 04
Human working memory capacity is limited. Studies show that reviewers can effectively handle about 200-400 lines of code changes at a time. AI-generated code often has higher logical density, so the actual reviewable code volume may be even less.
By chunking, each review unit is kept within a cognitively manageable range, allowing reviewers to truly understand the meaning and potential impact of each line of code.
When problems occur in code changes, small-grained commits make problem localization easier. There's no need to troubleshoot in hundreds of lines of changes—just focus on the recent few small commits.
Reviewers are more likely to provide constructive feedback when facing small changes. When facing large changes, reviews often become perfunctory ("LGTM") because the time cost of in-depth review is too high.
After task decomposition, multiple developers can handle different tasks in parallel as long as they follow the agreed interface contracts. This is particularly important in AI-assisted programming scenarios—multiple developers can use AI to generate code for different modules simultaneously.
| Dimension | Traditional Feature Branch | Agentic Workflow |
|---|---|---|
| Branch Granularity | One branch per feature | One branch per subtask |
| Commit Size | Large, containing the complete feature | Small, atomic changes |
| Review Timing | Unified review after feature completion | Review immediately after each subtask is completed |
| Merge Strategy | Single merge | Stacked multiple merges |
| Rollback Cost | High | Low |
| Applicable Scenario | Manual development | AI-assisted development |
Section 05
Rule of thumb: Control each task's code changes to within 100 lines (excluding tests). If the AI-generated code exceeds this scale, it means the task definition is not detailed enough.
Use tools or scripts to visualize the task dependency graph to ensure no circular dependencies. The order of stacked branches should be consistent with the dependency graph.
You can write scripts to automate the following operations:
Keep FEATURE_PLAN.md updated with the actual development progress. The status of completed, in-progress, and pending tasks should be clear at a glance.
The project provides supporting tools to facilitate this workflow:
These tools reduce the learning cost of adopting the new workflow, allowing teams to get started quickly.
Section 06
Agentic Coding Workflow represents the evolutionary direction of workflows in the AI-assisted programming era. It acknowledges and adapts to the characteristics of AI-generated code—fast but possibly rough, large in volume but possibly lacking overall consistency—by using process design to mitigate the problems caused by these characteristics.
This method is not only applicable to AI-generated code but also has reference value for any scenario requiring rapid iteration. Its core insight is: Process design should match the characteristics of production tools, rather than sticking to traditional practices.
For developers using AI programming tools, trying this chunked review workflow may significantly improve code quality and team collaboration efficiency.
Keep going with more reads from the same topic.
Splinter is a minimalist, high-performance key-value (KV) and vector storage system enabling zero-latency inter-process communication via shared memory and atomic operations. With only 766 lines of core code, it supports millions of operations per second and 768-dimensional vector storage, offering a new architectural approach for local LLM inference and data-intensive applications.
Folkering OS is the world's first AI-native bare-metal operating system, entirely written in Rust no_std without relying on Linux, POSIX, or libc. It can generate commands from scratch, compile them into WASM, and run them in 10 seconds, achieving true self-evolution.
This project explores how to use Large Language Models (LLMs) to detect logical vulnerabilities in Ethereum smart contracts, especially business logic flaws that are difficult for traditional static analysis tools to capture, such as economic manipulation and execution order errors.
Cross-generational hardware testing based on NVIDIA A10G and H100 GPUs, comparing and analyzing the throughput, latency, and concurrent scalability of three mainstream LLM inference frameworks. SGLang achieves a 3.4x performance advantage over vLLM on H100, while Ollama faces architectural bottlenecks in high-concurrency scenarios.