What Are We Really Criticizing When We Call Out “Pinduoduo-Style Open Source”?

Examining the shifting value metrics in open source through the lens of a 115k-star “text empire”

Recently, a friend sent me a GitHub link.

“Check this out.”

I clicked it and saw agency-agents-zh—a Chinese fork with 15.3k stars, 58 contributors, and 2.7k forks. It looked like a legitimate project at first glance.

But scrolling down the README revealed something different: massive cloud server sponsorship banners at the top, discount codes in the middle, and at the bottom—a lineup of WeChat official account QR codes, QQ group links, followed by a “sister projects” matrix: orchestration engines, methodologies, hands-on tutorials, desktop pet apps…

At the core of this entire repository? 266 Markdown-formatted AI prompt files.

No database. No core algorithms. No business logic. Tech stack breakdown: Shell 67%, PowerShell 31%, JavaScript less than 2%. The so-called “one-click installation script” is essentially just a file copy command.

I told my friend: “Isn’t this basically using GitHub like Pinduoduo? Not a single line of real code, ads plastered everywhere—what kind of garbage project is this?”

My friend paused for two seconds, then sent me another link.

agency-agents—the original upstream version created by American developers. 115k stars, 858 watching, 18.7k forks, 87 contributors.

My first reaction: “So Western developers are doing this too? And even more successfully?”

My second reaction: “Then what exactly am I angry about?”

Let’s set aside emotions for a moment. What did this project—both the original and the Chinese version—actually get right to earn so many stars?

First, it solves a genuine pain point.

AI tools have exploded recently: Claude Code, Cursor, Copilot, OpenCode, Windsurf… Developers switch between different tools daily, and each requires configuring “expert roles” and “system prompts.” What this project does is standardize these role definitions and provide installation scripts for 18 mainstream tools.

You don’t need to write prompts yourself or figure out each tool’s configuration file format. One command, and all roles are installed.

Its real engineering value isn’t in those 266 text files themselves, but in the engineering encapsulation capability for standardization and cross-platform distribution. It transforms a chaotic collection of prompts into an installable, maintainable, version-controllable “deliverable.”

Second, it builds cultural identity.

Looking at the original project’s README, you’ll find an incredibly complete narrative system: branded as “The Agency,” with unified emoji visual language. Each Agent has its own “personality,” “memory,” “mission,” and “deliverables.” It doesn’t tell you “here are some prompts”—it tells you “you can assemble your own Avengers team.”

Starring it buys into the fantasy of “I now have a hundred-expert team at my disposal.”

Third, it perfectly aligns with GitHub’s rules.

GitHub’s rules never protected “code purity.” GitHub protects “open source collaboration processes.” This project has 87 global contributors, with people submitting PRs, discussing issues, and improving documentation daily. In the platform’s eyes, this is a perfect community. What we see as “code nihilism” is precisely what the platform sees as “ecosystem prosperity.”

The original project, while sharing the same core, practices extremely restrained monetization: just a Sponsor button, no README-filling ad banners, no private WeChat group引流 (traffic funneling), no “sister products” matrix.

The Chinese version is completely different.

It takes the unspoken commercial logic of the original and executes it boldly using China’s internet-savvy traffic strategies.

A three-tier funnel progression: free bait captures attention → compliant sponsor ads enable direct monetization → private domain沉淀 (traffic retention) for ultimate harvesting. Every additional star boosts Trending rankings slightly, allowing ad space prices to increase incrementally. Users aren’t users—they’re carefully cultivated traffic.

Even more concerning, it taps into Chinese developers’ deepest anxiety: “Everyone’s using AI, everyone can develop independently—am I falling behind?” What it sells isn’t technology, but psychological reassurance: “I’m already on board.”

The original is like a religion; the Chinese version is like Yiwu’s wholesale market.

The original maintains dignity; the Chinese version cashes it in.

At this point, I want to pause for a reflection I wasn’t eager to make.

It’s easy to point fingers at “Chinese traffic operators with poor table manners.” But the original project’s 115k stars tell us this isn’t uniquely Chinese—it’s a global phenomenon.

The original is the “pope” of this model, proving to the world with 115k stars that in the AI era, text files can drive massive traffic and influence. The Chinese version is merely its “branch office,” executing a localized, simplified implementation in the Chinese market.

Without the original’s success, there would be no Chinese copy. The original invented the playbook; the Chinese version executed it to perfection.

So when we’re angry, what exactly are we angry about?

Are we angry at “Chinese traffic operators,” or at “the model itself”?

Writing this, I realize what makes me most uncomfortable isn’t the project itself.

It’s my growing awareness that the value evaluation system in open source is undergoing a paradigm shift I’m reluctant to acknowledge.

The old metric was simple: lines of code, algorithmic complexity, engineering depth. If you wrote a network protocol stack, optimized a query engine, or fixed a low-level bug—you were a valuable contributor.

But a new metric is emerging: knowledge structuring ability, ecosystem integration capability, and understanding of community psychology.

By the old metric, this project scores zero. By the new metric, it scores high.

This is what truly unsettles me—not that a project succeeded, but that an entire measurement system has been replaced.

You can keep calling it “The Emperor’s New Clothes” with the old metric, but those 115k GitHub stars weren’t gifted by the platform or artificially inflated—they represent 115,000 real developers voting with their feet.

They’re not fools.

They’re simply living in a changed world that we haven’t yet adapted to.

What Are Those Who Star It Actually Buying?

I asked myself: If I weren’t an engineer with ten years of coding experience, but rather a newcomer or someone wanting to learn AI without knowing where to start, how would I view this project?

Most likely: “Wow, 266 expert roles covering all departments, installable into my editor with one command, and it’s free.”

This appeal is real. It may not be noble, but it’s genuine.

It doesn’t target an engineer’s technical taste, but rather a learner’s desire for “efficiency” and “security.” What it provides isn’t code, but “path clarity”—in an age of information explosion, someone has organized things for you, and that’s value.

You might call this “selling anxiety-driven illusions,” but among those 115,000 stars, how many clicked with a “save for later” mindset? How many genuinely found it useful?

If we dismiss all “prompt-based projects” outright, aren’t we also using the “code purity” metric to reject an entirely different kind of value?

Conclusion

Writing this article has been a struggle. Intellectually, I acknowledge this project’s logic—it genuinely solves problems, achieves standardization and cross-platform compatibility, and has earned market recognition. Yet emotionally, I still feel “something’s wrong.”

This tension might represent the collective psychological state of technical professionals in our era.

The old temples are collapsing; the new order hasn’t stabilized. Some rush to paste ads and sell tickets amid the ruins; others stubbornly keep laying bricks and building walls. Who’s right?

We’re all footnotes of our time. Standing at different coordinates, we see different light and shadow.

I remind myself of a few points:

First, distinguish between “engineering integration” and “marketing patchwork.” The former solves distribution problems and deserves careful consideration; the latter exists only for traffic generation and should be avoided decisively.

Second, respect but don’t blindly follow traffic metrics. Star count indicates a project’s popularity, not its technical quality. 115k stars means it got certain things right, but doesn’t mean it represents open source’s direction.

Third, protect your craft. Regardless of how external evaluation systems change, what truly sustains the technical world remains those hard-core, silent lines of foundational code. Those things won’t become obsolete or disappear.

They’ve simply stepped out of the spotlight.

But I believe that after the noise of traffic-driven frenzy subsides, what will truly uphold this industry will always be those quiet corners nearly forgotten.

When the tide recedes, will these “text empires” become digital ruins?

I don’t know.

But I do know that as long as this industry needs even one line of core code maintained, it will always need true engineers.

And what we must do is ensure we remain those people.

Lifelong learning.