Building an Automated Code Review and Batch File Processing Pipeline with an AI Coding Assistant

1. Why Bring AI into the Development Workflow

In day-to-day development, two types of work are highly repetitive and governed by clear rules, yet often consume significant time:

1. Code review: Before each commit, developers must manually check for security vulnerabilities, performance issues, and style problems. Reviewers have limited time and may overlook important issues.
2. Batch file processing: Tasks such as renaming files, converting formats, adding comments, and upgrading dependencies are inefficient and error-prone when performed manually.

Command-line AI agents for software development—referred to as AI coding assistants below—are well suited to both use cases. They can read codebase context, execute commands, modify files, and be invoked from scripts, making them suitable for CI/CD pipelines and local hooks. Teams using cloud platforms such as Baidu AI Cloud can also deploy these pipelines in cloud-based development environments and combine them with general services such as object storage and log management to build a more complete automation loop.

2. Scenario One: Automated Code Review Before Commit

2.1 Define the Review Dimensions

A practical review workflow usually focuses on three fixed dimensions:

• Security: Hard-coded secrets, SQL concatenation, unvalidated input, unsafe deserialization, and similar issues;
• Performance: Repeated queries inside loops, N+1 problems, unnecessary full-table scans, and potential memory leaks;
• Code quality: Naming conventions, duplicated code, overly long functions, and missing error handling.

2.2 Standardize Review Criteria with a Prompt Template

Writing review criteria as a reusable prompt template is essential for producing consistent results. For example:

# .claude/commands/review.md
Review the code changes currently staged for commit across the following three dimensions:
1. Security: Check for secret leakage, injection risks, and unauthorized access.
2. Performance: Check for inefficient queries, repeated computation, and blocking operations.
3. Quality: Check whether naming, duplication, and exception handling follow team conventions.
Output format: | Severity | File:Line | Description | Recommended Fix |
Report only issues you are confident about. Mark uncertain findings as "Requires manual review".

2.3 Trigger the Review Automatically with a Git Hook

Call the AI coding assistant from .git/hooks/pre-commit:

#!/bin/bash
ai-cli --print "Execute the review workflow defined in .claude/commands/review.md" \
  > /tmp/review_result.md
grep -q "Severity.*High" /tmp/review_result.md && {
  echo "High-severity issues found. Commit blocked. See /tmp/review_result.md"
  exit 1
}
exit 0

This setup blocks high-severity issues locally before they reach the repository. Reviewers can then focus more on architectural concerns, improving the overall efficiency of the review process.

2.4 Advanced Approach: Delegate Reviews to Sub-Agents

As the rules become more complex, the three review dimensions can be assigned to independent sub-agents and executed in parallel. Each sub-agent can use its own prompt and output format, while the main workflow aggregates the results.

This divide-and-conquer approach reduces omissions caused by overly long prompts and allows the rules for each dimension to evolve independently.

3. Scenario Two: Batch File Processing

3.1 Common Task Types

• Batch refactoring: Standardizing function names and migrating calls to deprecated APIs;
• Batch generation: Adding documentation comments or unit-test scaffolding to each module;
• Batch conversion: Migrating configuration formats, compressing images, and archiving logs.

3.2 Safety First: Plan Before Executing

The greatest risk in batch operations is applying an incorrect change across a large number of files. A three-step process is recommended:

# Step 1: Ask the AI to generate a change plan without modifying files
ai-cli --print "List all files under src/ that use the legacy logging API and propose a migration plan"
# Step 2: Manually confirm that the plan is reasonable
# Step 3: Execute the approved changes under Git protection
ai-cli --print "Apply the approved migration plan"
git diff   # Review all changes
git checkout .  # Roll back at any time if necessary

Always run batch tasks in a clean Git working tree and keep every AI-generated change under version control. If something goes wrong, you can roll the changes back quickly.

4. Orchestrating Complex Automation with Visual Workflows

As a workflow grows to include prompts, conditional branches, user confirmations, and sub-agent calls, maintaining it as plain text can become difficult. In such cases, visual workflow orchestration can make the process easier to manage:

• Node-based modeling: Represent each step as a node and connect nodes to define the execution order. Common node types include prompt templates, sub-agent tasks, conditional branches such as If/Else, and user decision nodes;
• Property-panel configuration: Select a node to adjust its parameters without memorizing configuration syntax;
• Export and run: After the workflow is designed, export it as a configuration file recognized by the CLI and run it directly from the command line;
• AI-assisted iteration: Describe intended changes in natural language—for example, “Add an input validation step after the start node” or “Automatically split text longer than 1,000 characters”—and let the AI adjust the workflow structure. The workflow should also support reviewing and undoing changes.

This combination of no-code orchestration and AI-assisted editing allows team members with limited scripting experience to participate in building automation workflows, significantly lowering the adoption barrier.

5. Practical Recommendations and Common Pitfalls

1. Validate incrementally: Start with a single directory or rule, confirm that it works, and then expand the scope;
2. Use least-privilege permissions: Grant read access by default and require confirmation for write operations. Isolate nodes that interact with external networks;
3. Make results traceable: Persist each AI output as a log and use cloud-based log management for centralized search and auditing;
4. Version-control the rules: Store prompt templates and workflow configurations in Git and review them like code;
5. Keep human checkpoints: High-risk operations, such as deletion or batch overwriting, must include a user decision node and should not run fully automatically.

6. Conclusion

The value of an AI coding assistant is not simply that it can “write code for you.” Its greater value lies in automating repetitive, rule-driven work such as review, refactoring, and batch processing.

Starting with a single review prompt, then adding a Git hook, and eventually moving to visual workflow orchestration allows you to introduce AI into the development process incrementally. Every step should remain controllable, reversible, and auditable. That is the foundation for implementing automation safely and effectively.