AI-Powered Load Testing in Practice: Completing 30 Days of Performance Testing in 1 Day

Why Use AI for Performance Testing

Performance testing is an essential part of web system development, but traditional approaches come with significant pain points. Tools like JMeter not only have mediocre performance themselves, but also carry a steep learning curve that demands considerable time investment to truly master.

There are two core reasons why people default to JMeter: first, they lack the programming skills to build their own load testing tools; second, even if they do have those skills, building a fully-featured load testing tool from scratch takes too long. In the age of AI, however, all of this has fundamentally changed.

The approach described in this article combines a load testing tool called "Heiyu Loader" with an AI coding agent to dramatically accelerate every phase of performance testing — writing test cases, generating test data, running load tests, and producing analysis reports. What used to take 30 days can now be done in essentially 1 day.

Tool Setup and Environment Configuration

Installing the Base Environment

The entire solution runs on Node.js, with the load testing tool provided as an NPM package. Here's how to get set up:

1. Install Node.js: Both the load testing tool and AI-generated test scripts depend on the Node.js runtime
2. Create a project directory: Choose a suitable location on your machine and create a project folder
3. Install the load testing library: Navigate to the project directory and run the NPM install command
4. Initialize the directory structure: Run the initialization command to automatically create the required folders and config files

Choosing an AI Coding Agent

You can use any AI coding tool you're comfortable with — Claude Code, Codex, GitHub Copilot, and others all work. This article uses Alibaba's Qwen Code as the demo example, primarily because it offers a free tier, is beginner-friendly, and performs well with the Qwen CodePlus 3.6 model.

The key principle is: use whatever works best for you. The "intelligence level" of different agents will affect how detailed your prompts need to be.

Core Workflow: From Test Cases to Performance Reports

Step 1: Write Performance Test Cases

This is the phase that requires the most human involvement — and it's the most important. Many people think of performance testing as "grab a tool and start testing," but the right approach is to first analyze the actual usage patterns of the system under test and design realistic test scenarios.

Using a pharmaceutical order management system as an example, test cases should include:

• Data environment: 100 admin accounts, 1,000 customer records, 1,000 drug entries, 20,000 orders
• Test scenario: Simulate 100 admins operating during peak hours — one user logs in every 0.5 seconds, and each user sequentially browses the customer list, paginates, views drugs, adds a customer, adds a drug, creates an order, and so on
• Pass/fail criteria: Explicit performance thresholds, such as response time limits and maximum error rate

One important note: these documents aren't just for human readers — they're for the AI too. That means they need to be more detailed than traditional specs. For example, explicitly spell out username naming conventions and the logic for randomly selecting data. For more capable AI models (like Codex or Claude Code), you can keep descriptions brief; for less capable models, you'll need to spell out every detail clearly.

Step 2: Use AI to Generate Data Setup Code

Once you have the API documentation and project specs ready, craft a well-designed prompt to have the AI generate code for creating the test data environment. Key elements of the prompt include:

• Define the task boundary: "Write code to create the data environment (not the test scenario code)"
• Specify data sources: API endpoints, login credentials, and other details from the project spec
• Require intermediate data to be saved: Store generated customer IDs, drug IDs, etc. to a specified directory for use by subsequent load test code
• Request Chinese comments: Makes it easier to manually review whether the code logic is correct

The AI-generated script will automatically handle the full flow: super admin login → create admin accounts → create customer data → create drug data → create order data. Even without coding knowledge, you can read the comments to verify the logic is correct.

Pro tip: After the data environment is set up, take a database snapshot backup. If you need to re-run load tests later, you can restore the snapshot directly and skip the time-consuming data initialization step.

Step 3: Use AI to Generate Load Test Execution Code

For this step, your prompt should tell the AI to:

• Write test scenario code based on the project spec and test case documentation
• Read the previously saved ID data from the data environment directory
• Name the file run_test.js and save it to the test case directory
• Generate the code first, without executing it immediately (a lesson learned from experience)

Manual review after generation is critical. Go through the test case line by line and verify: login → list customers pages 1/2/3 → list drugs pages 1/2/3 → list orders pages 1/2/3 → add customer → add drug → wait 5 seconds → add order → repeat. The comments should make it clear whether the code faithfully reproduces the intended test scenario.

Step 4: Run the Load Test and Monitor in Real Time

Before executing, complete two preparation steps:

1. Start the stats center: Run the 黑鱼Loader stats center command and open the monitoring dashboard in your browser at http://127.0.0.1:14799
2. Deploy the resource monitoring agent: Deploy the monitoring program on the Linux host running the system under test to collect CPU, memory, disk, and other resource usage data

During the load test, the monitoring dashboard displays in real time:

• Requests/responses per second (QPS): Rises as virtual users increase in steps
• Timeouts/errors per second: Should ideally remain at zero
• Average response time: Reflects server-side processing capacity
• Concurrent connections: How this changes as user count grows
• Host resource usage: Real-time CPU, memory, and disk I/O status

If you observe anomalies — such as a spike in errors or a surge in response times — stop the test immediately and determine whether the issue is in the load test code, the system under test, or the test environment itself.

Step 5: Use AI to Generate the Performance Test Report

After the test completes, provide the AI with two types of data files:

• Load test performance metrics file (the locally auto-generated stats file with a perf prefix)
• System resource monitoring file (collected from the remote host)

Report generation is best done in two stages:

Stage 1: Generate a Markdown draft. Provide the test case, data files, and a report template, and have the AI fill in the execution results section. Manually review the data for accuracy and check whether the analysis is reasonable. Manually update any template sections not covered by the AI, such as hardware environment and software version details.

Stage 2: Convert to a formal HTML report. Transform the Markdown report into an HTML format with charts, inserting load test curve graphs and resource monitoring graphs.

The final report includes: test results summary (pass/fail), key metrics summary, response time distribution, throughput analysis, resource utilization analysis, key findings, and optimization recommendations.

Advantages and Considerations

Efficiency Comparison

Phase	Traditional Approach	AI-Assisted Approach
Learning the load testing tool	Days to weeks	Near zero
Writing test data scripts	Several hours	Generated in minutes
Writing load test code	Hours to days	Generated in minutes
Analyzing data and writing report	Several hours	Generated in minutes

Things to Watch Out For

1. AI cannot replace test analysis expertise: Scenario design and metric selection still require human judgment — that's the core value of performance testing
2. Always manually review AI-generated code: Use the comments to check each item against the test case and ensure the test logic is correct
3. Adjust prompts based on AI capability: More capable models can work with brief descriptions; less capable ones need every detail spelled out
4. Make good use of database snapshots: Avoid recreating the data environment from scratch for every test run — it saves a significant amount of time

Conclusion

At its core, this AI + load testing approach offloads the repetitive, templated work of performance testing to AI, while humans focus on the highest-value activities — test scenario analysis and results interpretation. It's not about replacing tools like JMeter; it's about offering a more efficient alternative path: no need to learn complex tools, no need to hand-write large amounts of code — just clearly describe your testing requirements, and AI handles everything from data preparation to report generation.

For developers and QA engineers who regularly need to run performance tests on web systems, this AI-driven load testing approach is well worth a serious try.