How AI agents accelerated performance test and report creation at Zásilkovna by more than 85%

How It Started

Packeta uses an extensive suite of performance tests for its public APIs. The QA team works with both REST and SOAP interfaces, preparing smoke tests, baseline scenarios, negative scenarios, and more complex workflow tests that chain multiple API calls together.

The team already had a well-established performance testing process. However, the most time-consuming parts were creating new tests and subsequently processing the results. Creating a single k6 scenario involved reviewing the documentation, preparing test data, writing API calls, adding checks, ensuring test data was cleaned up afterwards, and aligning everything with the conventions of the existing repository.

Manually, this took 4 to 8 hours. Large performance tests were then followed by an analysis of the results in Grafana and the preparation of two reports - a concise summary for management and a more detailed analysis for developers. This took approximately two additional working days and required a high level of attention and accuracy.

What We Set Out to Solve

The goal of the PoC was to determine whether AI agents could significantly accelerate two areas of work:

1. creating new k6 tests based on API documentation,
2. analyzing results and preparing reports for Confluence.

It was important that this was not just a one-off demo. The outcome needed to be a functional system that could be further expanded and used in the QA team’s day-to-day work.

Our Approach

We built the solution on Claude Code with the Superpowers plugin, complemented by a set of custom instructions and rules for working with the performance testing repository.

We created a set of AI agents, each with a clearly defined role. One agent prepared new k6 tests based on API documentation and existing repository conventions, reusing existing data and functions to avoid unnecessary duplication. Another agent analyzed performance test results, retrieved the required metrics from Grafana, evaluated them, and prepared reports for different audiences. A final agent could then publish the completed outputs to Confluence on request.

To make the solution sustainable in the long term, each agent had its own set of rules and instructions - known as skills - stored directly in the repository. This makes it clear which conventions the agent follows, which metrics it monitors, and how its outputs should be structured.

The implementation also included preparing the repository, setting up static code checks, creating a unified Grafana dashboard, and securely configuring access to the tools being used. This allowed the AI agents to work with the data they needed, while limiting their access to what was strictly necessary for their tasks.

How It Works in Practice

Today, a QA engineer can ask an AI agent to create, for example, a smoke and baseline scenario for a specific API, specifying the basic load parameters and test objectives. The agent reviews the available documentation, examines existing tests in the repository, and prepares a new test scenario according to the established rules.

The output is not code that is deployed immediately without human oversight. The QA engineer reviews the changes, adjusts any necessary details, runs a validation test, and decides when the changes are ready to be merged into the main branch. The difference is that instead of spending several hours preparing everything manually, the engineer receives a usable foundation within tens of minutes.

Report generation works in a similar way. The agent receives the test time window, retrieves the relevant metrics from Grafana, and prepares two outputs: a concise management summary and a more detailed technical analysis for developers. The QA engineer reviews and verifies the reports before deciding whether to publish them to Confluence or make further adjustments or clarifications.

The Results

We validated the PoC using real-world tasks. The results showed significant time savings in both areas evaluated - creating new tests and preparing reports.

The “With AI Assistants” times include the entire process, including manual review of the output.

After the PoC was completed, the AI agents, together with the relevant instructions, were handed over to Packeta’s QA team for day-to-day use. The solution therefore became more than just an experiment - it introduced a new way of handling repetitive tasks in performance testing.

What We Learned

The most important finding was not that AI can write a test or prepare a report. What mattered was its ability to take over the routine, time-consuming, but repeatable parts of the work: assembling template-based code, collecting metrics, performing initial analysis, and formatting outputs. The QA engineer remains responsible for reviewing, interpreting, and making decisions based on the results. The AI agent takes care of work that previously required hours or even days, giving the engineer more time to evaluate results, identify risks, and continuously improve the tests.