How to Perform Automated Code Review with LLMs: Prompt Examples and Workflows in 2026

How can automated code review be performed with LLMs? (Quick answer)

By using a code-specialized LLM, you can input raw source code into a structured prompt that triggers a series of checks: specification generation, zero-context review, security analysis, and automated refactoring. This workflow eliminates tedious manual checks and aligns with new tools released in 2026, such as Google AI’s Elephant-Goldfish plugin, Reason Machines’ Aspen Git server, and 0sec Labs’ security harness 0.

Why LLMs are the ideal choice for code review in 2026

Large language models (LLMs) have evolved from simple autocompleters to autonomous code reviewers. Today, they can:

• Generate detailed specifications before writing code (spec-first coding)
• Perform multiple zero-context review steps, replicating human cross-checking
• Identify security vulnerabilities, anti-patterns, and performance issues
• Propose refactoring and improvements based on repository best practices

These capabilities are enhanced by the new plugins and harnesses we mentioned. Google AI’s Elephant-Goldfish model ensures a five-stage review, Reason Machines’ Aspen provides a Git environment optimized for AI agents, and 0sec Labs’ security harness 0 adds automatic security checks directly into the workflow.

Current trends you’re already seeing in repositories

In 2026, teams adopting LLM-based code review observe:

• A 40% reduction in average review time
• A 30% decrease in bugs reaching production thanks to zero-context review
• A 25% improvement in security test coverage thanks to integration with the security harness

Which tools and pipelines to use today

When configuring an automated code review system with LLMs, consider this modern stack:

1. Code LLMs

• OpenAIGPT-4 Turbowith support for programming languages
Tipps open-source models likeCodeLlamaorStarCoderfor self-hosted implementations

2. Integrated plugins and services

• Google AI Elephant-Goldfish Model Plugin
• Reason Machines Aspen
• 0sec Labs 0

3. CI/CD pipelines

Use GitHub Actions, GitLab CI, or the new self-hosted offerings based on Aspen to automatically insert code into a review prompt when a commit is made.

Examples of prompts and practical workflows

Below is an example of a complete workflow that combines the three trends mentioned above. Feel free to adapt the prompts to your specific needs.

Workflow #1: Specification-based review

# Prompt: Generate specifications for a new API module
SYSTEM_PROMPT = """
You are a senior engineer. Write a detailed specification for a new REST API module that exposes user data.
Include: endpoints, parameters, data types, expected use cases, security constraints, and request/response examples.
"""

# Call the LLM
SPEC = llm_call(SYSTEM_PROMPT, context="api_module.md")
# Commit to Aspen
commit_to_aspen(SPEC, branch="spec-api-v1")
# Start zero-context reviews
for stage in range(5):
    review_stage = llm_call("""Review the following API module code and report any issues:
    {{code}}""", code=read_from_branch("spec-api-v1"))
    apply_fixes(review_stage)
# Start security harness
security_scan = run_security_harness(code=read_from_branch("spec-api-v1"))
"""

Workflow #2: Security check integrated with 0

# Prompt: Detect vulnerabilities in source code
SECURITY_PROMPT = """
Analyze the following code snippet to identify:
- SQL injection
- XSS
- Missing authentication
- Authorization issues
Provide a risk score and fix suggestions.
"""

# Perform the check within the CI pipeline
scan_result = llm_call(SECURITY_PROMPT, code=current_pr_diff)
# If risk score > 7, automatically open an issue
octopus_open_issue(risk_score=scan_result.risk, details=scan_result.fix_suggestion)
"""

Tips for successful implementation

• Use language-specific promptsfor more accurate reviews
• Implement a risk score
• Store previous review contextsin a vector DB for quick recall during subsequent reviews
• Combine LLM-based review with human oversightfor high-risk edge cases
• Leverage Aspen’s automatic branchingto isolate each review and maintain a clear audit trail

Conclusion: The future of code review is already here

LLMs have transformed code review from a slow, manual task into an automated, continuous process. With tools like Google AI’s Elephant-Goldfish plugin, Reason Machines’ Aspen Git server, and 0sec Labs’ security harness 0, you can integrate quality, security, and performance checks directly into your development cycle. Start with a single prompt, expand the workflow, and watch your codebase become more secure and maintainable every day.