Skip to main content
  • Home
  • Library
  • Read
    • Popular
    • Charts
    • Browse
    • Categories
    • Wikis
    • Glossary
  • Request
  • Activity
  • Leaderboard
  • Help
Our Apps
  • DaoSearch
  • Narratorr
Social
  • Discord
  • Patreon
The AI Wave Tycoon's Rise
Chapter 207

How did they do it?

1,895 words 6 min read 1 view 1mo ago Source ​
Skip to the end of the chapter
Prev
Next

"Snort."

A sneer crept onto Ryan's lips. The entire Silicon Valley was scrambling to research this new paradigm, and a small company in China wanted to be the first to launch it? They were simply overestimating themselves.

He thought Sarah was overreacting, especially sending him messages in the middle of the night.

It's also possible that Sarah just sent the message to prove she was working overtime that night.

Ryan had worked as an employee before, Supreme Purity these kinds of thoughts.

But since he had already opened the page, he was willing to spend some time looking at it to see what the China team could achieve and how far they were from the world's top teams.

Ryan glanced at Riding the Wind's product landing page, which featured features like automatic task breakdown, automatic code generation, and automatic test execution.

To be honest, these descriptions are rather unremarkable; the leading companies in Silicon Valley are all researching this.

It's easy to say, but difficult to actually make it.

If I really wanted to create this self-operating tool, the engineering problems to be solved and the limitations of Large Model capabilities to be bypassed would be far beyond what can be accomplished by simply writing a few sentences in a product introduction.

Only those who have actually experienced it firsthand know how deep the water really is.

Every sentence on the page seemed perfectly logical, but precisely because it was so logical, Ryan saw right through it: this China company was just playing a gimmick.

The product wasn't even made yet; they just took the paradigms discussed in the industry, repackaged them, and claimed they had already achieved them. Ryan recalled Han Luyi's eloquent speech in the video conference.

China people just love doing these fancy and flashy things.

Ryan patiently found the login page and downloaded the tool. This tool, called Riding the Wind, currently only supports command-line interface (CL1) usage. After starting it, you need to enter a username and password to verify before you can start using it.

This is a small distributed scheduler written in Go. It's half handwritten and half generated by the Mercury Model, so the code quality isn't high. But it's barely runnable, and it didn't take much time—less than a week in total.

This project has virtually no documentation or comments; a typical programmer would probably be completely baffled.

"Perfect, "Ryan thought, "Let's test your mettle."

He typed a line of English, asking Riding the Wind to Add One feature to the project.

Cancel cascading after a task times out.

He wanted to implement this feature but didn't because it involved the lifecycle management of at least four files and two goroutines, and also had to be compatible with the messy event bus he had previously written.

The most troublesome thing is that this project has a historical baggage. When he first started writing it, he was lazy and stuffed a module that should have been decoupled directly into the main loop.

The similar tool that Neus is still working on internally is called Neus Atlas. Ryan also uses this project to test Atlas, and he always fails because of this coupling.

He wanted to see what mistakes Riding the Wind would make in this line of reasoning.

Press Enter.

The terminal started scrolling.

As you can see, Riding the Wind first scanned the warehouse structure.

"This is nothing," Ryan thought, raising an eyebrow.

Then Riding the Wind began reading the code, marking several files that he considered relevant.

Ryan leaned forward.

Wrong.

How does it know that the event bus is relevant? The landing page doesn't mention "event bus," nor does the command he typed mention it.

Moreover, it quickly skipped over those names containing "task" or "timeout".

The files contain logic that has absolutely nothing to do with the changes required in this case. These are the kinds of fake, seemingly relevant files that are most likely to fool beginners.

It seems to have truly understood the project, knowing which module is the core and which code is a legacy issue.

It's as if it wrote the program itself.

Ryan's cold smile slowly disappeared from his face.

The terminal continues to output text.

Riding the Wind presented the first version of the modification plan. It did not touch that historical baggage, but instead added a signal broadcast layer to the event bus and attached the cascading cancellation to the broadcast layer.

Ryan stared at the screen.

This was exactly the solution he had come up with, but hadn't implemented because he was too lazy to modify the event bus.

Don't panic, it's just a coincidence.

Ryan told himself this silently.

He leaned back in his chair, forcing himself to come up with a reasonable explanation: the event bus was a core module in this project, with the largest file size, so being scanned was just a matter of probability. If the team had put extra effort into the logic of scanning the files, it wouldn't be impossible for them to have achieved this. They might just be good at this.

This explanation is valid.

Riding the Wind continued working, starting to write code. Ryan stared at the terminal, waiting for it to make a mistake due to historical baggage. That module coupled into the main loop, Atlas: it always crashes here.

However, Riding the Wind made no mistakes, and the coupling logic was completely cleaned up.

Riding the Wind even completed the unit tests before refactoring.

The old code was drastically removed, and the newly generated code has a clear structure.

Riding the Wind automatically ran the unit tests again.

All green, passed on the first try.

Ryan's face showed disbelief.

How is this possible? This tool is even more powerful than Atlas?

Undeterred, Ryan opened another example in the Atlas test library, the most nasty one in the library, case-42.

To date, Atlas has never been able to complete a single test.

Ryan typed in the standard test prompt, waiting to see where this Riding the Wind would stumble.

However, five minutes later, Riding the Wind passed the test on the first try. The code was elegant and the comments were complete. It didn't look like code written by AI at all.

Ryan had to force himself to accept the status quo.

Compared to Neus Atlas, it can generate code from requirements documents, but it will encounter two typical failures every time it is run in an existing code repository.

One type is unable to find the right context. Give it a task to fix a bug, and it will search aimlessly in a folder with 100,000 lines of code, digging out completely unrelated files and stuffing them into the prompt words, then generating a code that looks very professional but is completely unworkable.

Another type involves finding relevant code by chance, but still not being able to fix it correctly. Even if the context is correct, the model often cannot distinguish which part is the constraint to be followed and which part is just a reference, resulting in very unstable results. Sometimes it works, and sometimes it doesn't. Determining whether it can be used requires almost as much effort as writing it directly.

For these two types of problems, Neus's research and engineering team has improved the accuracy considerably since August, but it's still far from usable.

As for the new tool, Riding the Wind, it seemed to have solved the problems beautifully, at least in the two tasks he had just tried.

Ryan felt a bit warm in the room. He tugged at his collar and then looked down at the time on his computer: 10:37 PM.

Ryan then looked at Sarah's chat window.

Sarah's last message was ten minutes ago.

"There's a review of the 'Riding the Wind' phone on a China online forum that's generating a lot of discussion. Please take a look. [Link]"

Ryan then looked at the chat history above the dialog box.

"My development team and I just tested it together, and it's much more complete than ours!"

This is what Sarah just sent. Ryan initially thought Sarah was making a fuss, but now this sentence seems particularly jarring.

He didn't click on Sarah's link; instead, he picked up his phone and dialed Sarah's number.

"--Uh, hi?" Sarah was a little surprised when she answered the phone. Although she often reported on her work at night, her boss rarely responded directly. In Silicon Valley, even in startups, bosses still try to maintain a superficial culture of "discouraging overtime."

"Sarah, contact the heads of the engineering and research teams, and the marketing manager now. There's an online meeting in half an hour," Ryan checked the time again, "...11 o'clock. I'll contact John."

John Snow is the CT0 of Neus Al.

"Eleven o'clock?" Sarah confirmed again on the other end of the phone. "Today? Now? Eleven o'clock? Eleven o'clock tonight?"

The amount of information in that phone call was clearly overwhelming, disrupting her thought process.

"Yes," Ryan said. "Make sure all the responsible parties are online. Message them, call them, or just go to their homes and knock on their doors. Basically, make sure everyone is online."

After saying that, Ryan hung up the phone.

He then contacted John and gave him a brief description of the test he had just conducted.

John paused for a moment on the other end of the phone, then said, "I'm coming right now."

John's and Ryan's houses are not far apart, only a five-minute drive apart.

After hanging up the phone, the study fell silent.

Sitting at his desk, Ryan looked back at the screen and opened the post Sarah had sent.

The post was in Chinese, Ryan used a translation plugin to translate the page, so it reads fairly smoothly.

Old Zhang lamented in the post: Riding the Wind restructured his payment module and unilaterally deleted a piece of deduplication logic he had written without any warning.

"It doesn't know it doesn't know," "Pandora's Box," "The foundation of the internet" --

After reading the article, Ryan leaned back in his chair and looked out the study window.

"This guy doesn't know anything," Ryan muttered.

Old Zhang thought he was cursing Riding the Wind.

What Old Zhang didn't know was that the system beneath Riding the Wind, which handled intent understanding, Task Orchestration, and technical decisions, was none other than Neus's Large Model —the Mercury Model.

Mercury Model's decision-making style is like this: aggressive and confident. It will "change" any redundant code that does not conform to the standards, and will never keep anything that can be deleted.

This is a technical direction that Ryan and his research team deliberately chose. Now the competition for Large Model has become fierce, with a few giants holding such a high market share. As a startup, how can Neus find its own niche?

A ruthless and taciturn technical elite—that's the role Neus chose for the Mercury Model.

Old Zhang's deduplication logic was quietly deleted, not because of Riding the Wind's "illusion," but because of Mercury's "temperament."

Old Zhang attacked the wrong target.

However, the real strength of Riding the Wind lies in finding the right context, identifying historical baggage, and completing the entire task without human intervention. These are the core values of Riding the Wind as a workflow orchestration tool.

The model can be changed; you can replace the radical one with a conservative one, or replace the Mercury Model with another company's model, and then Old Zhang's deduplication section might be preserved.

But what Ryan is most curious about now is, how exactly did the Source Code Technology team manage to do that?

End of Chapter
Prev
NovelSummaries
Next

Explore the wiki

Han Luyi

Comments

No comments yet.
AboutStatsAPIChangelogStatusContactPrivacyTermsDMCA
© 2026 RandomTranslator·v3.26·RSS