跪拜 Guibai
← Back to the summary

Coding Agents Get Their Own Infrastructure: 8 Trending Projects, 1.35M Stars, 14 Months


theme: channing-cyan

01-cover.jpg

Yesterday I scrolled through GitHub's trending page, hoping to find a couple of useful little tools.

Halfway through, I noticed a striking pattern: the top of the list was almost entirely free of models and applications. All of them were tackling the same problem—how to make coding AI agents do their work better.

Among the 20 projects, using the criterion "produce no business value themselves, exist only to improve agent capability," I filtered out 8. Their total stars are roughly 1.35 million, and all were created within the last 14 months.

This article does three things: lays out the data, groups the 8 projects into three abstraction layers, explains why this is happening now, and looks at the new risks it brings.


1. Method and Data

No second-hand rankings. Star counts were pulled directly from the GitHub REST API, script below:

for r in obra/superpowers affaan-m/ECC morluto/rea stablyai/orca; do
  printf "%-40s " "$r"
  curl -s "https://api.github.com/repos/$r" \
    | python3 -c "import sys,json;d=json.load(sys.stdin);print(d['stargazers_count'], d['language'], d['created_at'][:10])"
done

Anonymous calls without a token are rate-limited to 60/hour; batch queries need Authorization: Bearer $GITHUB_TOKEN.

Snapshot date: 2026-11-19. Stars are a point-in-time snapshot; they change with platform cleanups and project inactivity. The numbers here should not be used as long-term conclusions.

Results (only the 8 I actually queried):

Project Stars Language Created Positioning
morluto/rea 468,335 TypeScript 2026-04-14 Reverse engineering with agents, from app behavior to underlying native implementation
obra/superpowers 321,338 Shell 2025-10-09 Agent-oriented software development methodology framework
affaan-m/ECC 306,531 JavaScript 2026-01-18 Performance optimization system for agent harness, 67 agents / 284 skills
stablyai/orca 128,924 TypeScript 2026-03-17 Run a fleet of agents in parallel, isolated with independent worktrees
pingdotgg/t3code 65,269 TypeScript 2026-02-08 Remotely control local Claude Code / Codex from across devices
ccch1mneyyy/dsh-Go 27,234 Dart 2026-10-25 Mobile client for DeepSeek Harness
GoogleChrome/modern-web-guidance 22,874 — 2026-03-23 Inject the latest web standards and compatibility data into coding agents
elementalsouls/Claude-BugHunter 11,394 Python 2026-05-05 Claude Code vulnerability hunting skill pack

02-grid.jpg

A notable temporal distribution: the earliest, superpowers, was created in October 2025; the latest, dsh-Go, on October 25, 2026. The entire category's lifecycle is under 14 months.

rea's 468K stars is the most counterintuitive—a repo created in April 2026 has more stars than most established frameworks. That alone should be treated as a signal: at this stage, stars measure hype, not maturity.


2. Three Layers, Not Eight Parallel

Lay these 8 out and align them: they are not on the same level. By abstraction position, they split exactly into three layers:

┌─────────────────────────────────────────┐
│  L1  Skills / Methodology               │   tells the agent how to do things
│  superpowers · ECC · BugHunter · MWG     │
├─────────────────────────────────────────┤
│  L2  Orchestration                      │   run several agents at once
│  orca · t3code                           │
├─────────────────────────────────────────┤
│  L3  Harness / Runtime / Transport      │   where the agent runs, how it connects to tools
│  dsh-Go · rea                            │
└─────────────────────────────────────────┘
              ↓ all built on the same foundation ↓
        Claude Code / Codex / Cursor CLI

03-layers.jpg

L1 · Skills: turning engineers' processes into files agents can read

superpowers covers software development methodology: requirements clarification → design review → implementation plan → TDD → code review.

ECC is more aggressive, with 67 agents, 284 skills, and a context management mechanism.

Claude-BugHunter turns pentesting flows into 83 skills, 15 slash commands, and 681 vulnerability patterns.

modern-web-guidance turns browser compatibility—"knowledge that changes every year"—into agent-queryable skills.

Their common thread: the content is not code, but specifications. It translates the process in a senior engineer's head into structured text that machines can read.

L2 · Orchestration: from "using one agent" to "managing a fleet of agents"

orca's core design gives each agent an independent git worktree—so multiple agents working on the same repo in parallel don't overwrite each other. That's a practical choice: it sidesteps the hard problem of "how to merge conflicts between multiple agents" by isolating at the filesystem level.

t3code solves a different problem: the agent runs on your machine, but you're out. It extracts the control plane and makes it cross-device.

L3 · Harness: runtime and tool integration

dsh-Go stuffs DeepSeek Harness into Android; runs locally and can remotely control the desktop. rea provides a unified MCP framework that lets agents mount various reverse-engineering tool modules.

This layer matured latest and depends most on protocol standardization.


3. Under the Hood: What a Skill Actually Looks Like

The most reference-worthy thing among these 8 projects is L1's directory organization. Below is a schematic structure I organized based on common practices in such projects (not the actual files of any specific repo, just an illustration):

.claude/skills/
├── code-review/
│   ├── SKILL.md          # metadata: name / description / trigger conditions
│   ├── checklist.md      # concrete checklist items
│   └── examples/
│       ├── bad.md
│       └── good.md
└── tdd/
    ├── SKILL.md
    └── templates/
        └── test-skeleton.ts

The SKILL.md metadata usually looks like this:

---
name: code-review
description: Perform a structured review of changes. Use when the user asks for a review,
             checks a diff, or does a pre-commit self-check.
---

## Process
1. Read the diff first, not the whole file
2. Go through checklist.md item by item
3. Mark each issue: [Blocker] / [Suggestion] / [Question]
4. Self-check before output: is there an actionable change?

The key is the description line. It determines when the agent proactively loads this skill—in essence, a routing rule written for the model. Write it vaguely, and the skill never gets triggered; write it too broadly, and it pollutes the context.

That's why I say the real technical content in L1 isn't code, but engineering of prompt engineering.


4. Why Now

All three layers grew out simultaneously because three preconditions aligned.

04-fleet.jpg

1. The interactive surface of CLI agents has converged.

Claude Code, Codex CLI, and Cursor's command-line version all essentially consume the same primitives: read files, write files, run shell, read instruction files. Once the interface is unified, "generic skill packs" become meaningful—otherwise they'd need to be rewritten for each platform.

2. MCP unified the tool protocol.

Before this, connecting a database or a browser meant writing a separate integration for each platform. After MCP, write once and use everywhere, which is why "toolbox" projects like rea became viable.

MCP configuration looks roughly like:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"]
    }
  }
}

3. The bottleneck shifted from "how smart the model is" to "how well the context is fed".

This is the most critical point. When top models' performance gap on routine coding tasks narrows to a few percentage points, what decides output quality is: what constraints, what process, what boundaries you give it.

So the reader of "documentation" has changed—formerly written for newcomers, now written for agents. This is the root cause of the L1 explosion.


5. Risk Checklist

High stars don't equal usable. This section may be the most worth reading.

05-toolbox.jpg

① Stars ≠ usage.

Clicking a star costs nothing. During a trending boom, the relationship between stars and real weekly active usage becomes very loose. A repo with 460K stars may have far less real usage than intuition suggests. When evaluating these projects, look at Issues activity, Release frequency, and the last commit, not stars.

② Skill packs are a new supply chain entry point.

This is the most underrated risk, I think. The traditional dependency risk model is "the code in the library gets executed," but now there's a new one: instructions in a skill pack get executed as commands by the agent, using your permissions.

A skill pack that automatically finds vulnerabilities and builds attack chains (like Claude-BugHunter) is handy. But the same mechanism can be used for other things. The rigor of reviewing a skill pack should be equivalent to reviewing a script that will run on your machine—at a minimum, check what tool permissions it asks for and whether it exfiltrates data.

③ Skill conflicts and context bloat.

Install 20 skill packs into one project, and the agent will drown in its own instructions. Context budgets are finite, and every description takes up space. My experience: 3–5 skills per project is a reasonable cap; beyond that, start merging.

④ Short project lifecycle.

Most of these 8 are maintained by a single person or a small team, and the earliest is only a year old. Before betting on one, check: does it have CI? An issue template? Have external PRs been merged in the last three months?


6. Three Steps for Teams

If you just want to try things out, clone the hottest ones. To bring them into a team project, I'd suggest this order:

Step 1: Copy the structure, not the content.

Spend 20 minutes reading the directory organization of superpowers and ECC, understand what parts a skill file is composed of. Then rewrite your team's own review checklist into the same format. The output is "your own skills," worth far more than installing someone else's.

Step 2: Confirm permission boundaries.

Ask three questions about every skill pack you plan to install:

If any one of the three answers isn't clear, don't install it into an environment with production credentials.

Step 3: Run a controlled experiment.

On a repo you know well, run the same batch of tasks with two groups: one with skills, one without. Compare token usage, rework count, and the number of issues found in code review. Without a control, there's no validation.


7. Conclusion and Preconditions

My judgment: this round's real competition isn't at the model layer, but in "who can standardize agents' context and processes."

This judgment rests on three preconditions, written down for future debunking:

  1. The capability gap between top models on routine coding tasks continues to shrink;
  2. CLI agents' filesystem / shell / instruction-file interfaces remain compatible;
  3. MCP doesn't fragment (i.e., doesn't produce two or three mutually incompatible mainstream protocols).

If any one of these collapses, half of the 8 projects above would instantly lose their reason to exist.

06-future.jpg


8. Final Thoughts

In the previous AI wave, the shovel sellers were compute and models.

This wave, the shovel sellers haven't made much yet, but those who write instruction manuals for the shovels are the first to get hot.

14 months, 1.35 million stars. How much of that number is real value won't be known until these projects survive two years. But it at least shows one thing: developers have universally realized that what determines the quality of AI output is no longer just the model itself, but how you organize the context you hand it.

If you're doing similar work, feel free to share the pitfalls you've hit in the comments—especially around skill conflicts and permission boundaries, where public experience is still scarce.