Let the Product Speak

First round. Go microservice framework. Thirty-two thousand lines.

Two progress bars started running simultaneously on the big screen. Blue CodeSafe on the left, green BugKiller on the right. There were forty-one thousand online viewers, and the number was still climbing.

CodeSafe scanned slightly faster, its progress bar reaching 100% first.

The comments immediately flooded in.

"CodeSafe is so fast."

"Wait, BugKiller isn't done yet?"

BugKiller's progress bar was about seven seconds slower before it reached the top as well.

The scan results were not displayed directly. Under the competition rules, each round had to be verified on-site by a five-member technical expert panel: technical leads from the three companies and two veteran contributors from the open-source community. They confirmed each item as a real bug or a false positive before displaying the verified data.

The expert panel gathered around the monitor and began reviewing the results. The comments grew impatient. "Hurry, hurry, hurry." "What's the rush? They have to examine the code one item at a time."

Six minutes later, the verification results appeared on the screen.

CodeSafe: 24 total flags, 24 confirmed bugs, 0 false positives. False-positive rate: 0%.

BugKiller: 23 total flags, 22 confirmed bugs, 1 false positive. False-positive rate: 4.5%. Each item included an impact assessment and a fix path.

The head of the expert panel took the microphone. "At the thirty-thousand-line scale, both tools performed well. CodeSafe detected two more issues with zero false positives—clean and efficient. BugKiller had one false positive and detected two fewer issues, but the impact assessments and fix paths attached to each result are features CodeSafe lacks. Overall, CodeSafe holds a slight edge in the first round."

Zhao Wenyuan leaned back in his chair and nodded toward the camera. "Both products have their own strengths. But in standardized code-review scenarios, detection rate and precision remain the hard metrics."

The comments rolled by rapidly.

"Did CodeSafe win the first round?"

"Zero false positives really is impressive."

"BugKiller's impact assessments are pretty interesting, but it detected two fewer."

"Is NullPointer going to lose?"

"It's only the first round. Don't panic."

Han Luyi showed little reaction throughout. He glanced at the data on the big screen, nodded, then lowered his head and took a sip of water.

Some viewers noticed. "NullPointer's mentality is way too steady." "He lost a round and looks like nothing happened." "Is he calm, or just putting on an act?"

Su Niannian was curled up on the bed in her rental apartment, the blanket pulled up to her chest, her laptop balanced on her knees. The left half of the screen showed the livestream, while the right half showed BugKiller's backend. Her phone lay charging beside her pillow, next to a small pile of orange peels.

When the first-round results came out, she stared blankly at the screen for two seconds. CodeSafe had won?

She opened WeChat and sent Han Luyi a message: "Aaaah, we lost the first round."

No reply. Then she thought about it. Right—he was livestreaming. There was no way he could look at his phone.

She put down her phone and began peeling her fourth orange. She calculated silently: thirty thousand lines in the first round, and CodeSafe won. One hundred twenty thousand lines in the second. Three hundred fifty thousand lines in the third.

In the previous comparison test with eighty thousand lines, BugKiller had already pulled ahead. The gap would only be wider at one hundred twenty thousand lines.

"The first round was never our home turf," she said to the screen. No one heard her.

The host said, "Thank you to both sides. The first-round results are now displayed on the screen. We will now proceed to the second round: a Python data-processing platform, approximately one hundred twenty thousand lines of code."

"Begin."

The progress bars started running again.

This time, the difference in speed appeared from the very first second.

BugKiller's green progress bar advanced at a steady pace, roughly the same rhythm as the first round.

CodeSafe's blue progress bar was noticeably slower. It was normal at 10%, began dragging at 20%, and at 30%, it seemed to hit something, pausing for two seconds before jumping to 31%.

The comments were more sensitive than the experts.

"Did CodeSafe freeze?"

"It's normal, it's normal. One hundred twenty thousand lines really takes time."

"BugKiller isn't stuck. Look at that green bar."

"The speed gap is showing."

BugKiller finished first. Han Luyi leaned back in his chair, his hands clasped behind his head as he waited. BugKiller's results were already arranged neatly on the screen—fifty-eight detections in all.

CodeSafe's blue progress bar was still at 78%.

The comments began counting down. "It's at 80, it's at 80." "Almost there, almost there." "This speed gap..."

After waiting nearly two minutes, CodeSafe finally reached 100%.

The comments said, "Only seven seconds apart in the first round, but two minutes apart in the second." "A gap this big at one hundred twenty thousand lines?" "The codebase quadrupled, but the gap grew more than tenfold."

The expert panel began verification. This time, it took longer than the first round. Viewers could see the experts repeatedly comparing the code, with some of them frowning and flipping back to review it again.

Eleven minutes later, the verification results appeared on the screen.

BugKiller: 60 total flags, 58 confirmed bugs, 2 false positives. False-positive rate: 3.4%.

CodeSafe: 48 total flags, 41 confirmed bugs, 7 false positives. False-positive rate: 17.1%.

The head of the expert panel did not smile this time. "CodeSafe had seven false positives. Four of them labeled normal exception-handling logic as bugs, showing that as the codebase grows, its detection engine's contextual understanding declines. Of the seventeen additional issues detected by BugKiller, fifteen were confirmed as real bugs."

There were forty-six thousand viewers online. The comments grew denser and denser.

"17%???"

"The experts said it—once the scale gets big, it can't handle it."

"A 17% false-positive rate is completely unusable in a production environment."

"BugKiller is steady as a rock. 3.4%."

Zhao Wenyuan stared at the numbers on the screen. The livestream could not be paused, and he could not check the logs. Everyone was watching him.

"A one-hundred-twenty-thousand-line project does indeed place greater demands on the detection engine. We are currently iterating on and optimizing the next version."

Han Luyi's voice came from the right. It was not loud, but the microphone picked it up clearly.

"Dr. Zhao, let's begin the third round."

The comments said, "Not giving him time to explain." "The way to respect your opponent is to end it quickly."

The host looked at both sides.

"Third round: a Java enterprise core system, approximately three hundred fifty thousand lines of code."

The online viewer count broke fifty thousand. The comments paused for an instant. Fifty thousand people held their breath at once.