AI agents in projects: tests instead of review

Parallel AI Agent Work Across Multiple Projects: Practices and Challenges

Middle and senior developers increasingly manage multiple projects simultaneously, each running Claude AI sessions in their IDEs. Instead of traditional code reviews, teams now favor generating test scenarios and dry runs for black box testing. This accelerates iteration cycles but burdens the operator—constant context switching leads to reduced downtime, making humans the weakest link in the pipeline.

Testing Over Review: A Case Study with an EVM Bot

Rather than manually reviewing code, the approach involves: the agent generating implementation, the operator defining test scenarios and log analysis. Consider a Rust-based bot that fetches price data from external sources and updates an EVM smart contract:

• Subscribing to CEX events via WebSocket.
• Sending transactions when prices change.

Predefined optimizations include:

• nonce calculated offline, avoiding eth_getTransactionCount.
• Fixed gasLimit, bypassing estimateGas.
• Only sendRawTransaction, using round-robin distribution across addresses.

After generation, validation occurs without code inspection:

// Example dry run scenario for verification
mock_send_tx();
log_analysis();

Test Scenarios and Iterative Refinement

The operator defines a sequence of tests to cover edge cases:

• Parallel code review from current and clean contexts;
• Handling source outage scenarios;
• Monitoring gasPrice to prevent deposit drain;
• Benchmarking tick processing time (asynchronous tx sending?);
• Mock transaction sends with dry run and log analysis;
• Background services: balance, nonce, and confirmation monitoring;
• Synchronization checks between components.

Each step is iterative—the agent refines based on new scenarios. The result? A functional bot covering happy path and known issues, all without manual code review. This method works best when the operator has domain expertise and anticipates pitfalls.

Pitfalls When Expertise Is Lacking

Problems arise when the operator lacks insight into optimal solutions:

• Describing options to the agent doesn’t trigger automatic research or selection of the best approach.
• The agent demands clarifications instead of self-analyzing.
• The operator defaults to passive waiting, hoping for 'magic' results.

This underscores a key truth: AI amplifies, but does not replace, human expertise. The developer’s role evolves into that of an AI expert-operator:

• Managing N projects in parallel.
• Deep domain knowledge.
• Full accountability for outcomes.

Key Takeaways

• Tests and dry runs are more effective than code reviews for rapid validation in non-critical zones.
• RPC optimizations (offline nonce, fixed gas) are critical for high-frequency EVM bots.
• Iterative scenarios cover edge cases without requiring code inspection.
• Operator expertise is essential—AI cannot autonomously solve unknown problems.
• Future direction: orchestrating agents and operators within a unified task environment.

The Future of Orchestration

To address context-switching fatigue, orchestration tools are essential:

• Unified project information space.
• Dashboard showing tasks, idle agents, and active context.
• Operator assignment by permissions and skill level, like a hotline system.

These tools enable workload distribution, minimize agent downtime, and stabilize workflows. Running multiple IDEs and Claude sessions in parallel is becoming standard—requiring discipline and robust tooling.

— Editorial Team