跪拜 Guibai
← Back to the summary

Inside REA: What a 37-PR Contributor Learned About AI Project Review Culture

Deconstructing the World's Most Popular AI Open-Source Project · Season 1 · REA

This isn't a tutorial on using REA. It's about understanding why modern AI open-source projects can evolve at high speed, using REA as the lens.


REA

GitHub Global Star Ranking #4

The fastest-growing AI open-source project of 2026


My rankings over the past few months

Merged PRs Top Contributors
37 #10

(Among human PR contributors: #8)


This is the first time I'm speaking about this project as a Contributor, not as a user.


Chapter 1: I Was Deeply Wrong

The first PR I submitted to REA seemed well-written to me.

The change was small, the logic clear, tests ran, CI passed, and the description included a comparison table. I submitted it and waited for it to be merged.

A few minutes later, the bot came.

It said P1.

Reject truncated wide caches before accepting 28-byte headers

If a valid 32-byte cache is truncated by exactly four bytes at EOF,
bytes.length - declaredPayload becomes 28 and this allow-list accepts
it as the narrow layout.

I stared at that paragraph for a long time.

My first thought was: It's wrong.

Because my PR contained "evidence." I ran real Node, extracted a 64-bit V8 code cache, removed the four padding bytes at the end, and handed it to V8 itself to decide.

new vm.Script(src, { cachedData: narrow }).cachedDataRejected
→ false

V8 accepted it. So those bytes were valid. So my implementation was correct.

That reasoning looked airtight.

Then I decided to "prove it wrong" by running all three cases.

mermaid diagram

V8 even accepted the truncated corrupted file.

I had turned an experiment that proved nothing into critical evidence and written it into the PR description.

The feeling at that moment wasn't "I've been wronged." It was "what I did was shallower than I thought."


Hours later, I found the real discriminator. I ran six different sources and measured two constants:

x64 padding word, offset 28   always 0x00000000
first payload word, offset 32  always 0x03542401

Only that 0 can distinguish a true 28-byte header from a truncated 32-byte header.

Because that 0 is V8's alignment padding, whereas a genuine 28-byte header stores the first payload word at that position.

mermaid diagram

The PR finally read:

| container | before | after | | true 32-byte header | accept | accept | | true 28-byte header | accept | accept | | 32-byte header truncated by 4 | accept | malformed |

Two unchanged rows and one changed row carry equal weight.


That day I learned more than in a year of writing code on my own.

So the first sentence of this series is:

I'm not here to teach you how to use REA. I'm here to tell you how wrong one person's judgment can be in a project with hundreds of thousands of stars, and how it straightens you out.

Chapter 2: Why the Whole World Is Talking About It

Start with the simplest question: What scale of project is this?

2.1 Global #4

mermaid diagram

1  codecrafters-io/build-your-own-x          562,490
2  sindresorhus/awesome                      536,805
3  public-apis/public-apis                    498,972
4  morluto/rea                                459,260   ←
5  freeCodeCamp/freeCodeCamp                  459,128
6  EbookFoundation/free-programming-books     401,586

#4 and #5 are only 132 stars apart.

That position can flip any time. So "global #4" is a dynamic snapshot, not a settled fact. I might have to change this sentence next week.

2.2 It's Only Been Around for 7 Months

That's the truly absurd part.

mermaid diagram

I pulled every repository created in 2026 and sorted by stars:

1  morluto/rea                     459,260   created 2026-04-14
2  mattpocock/skills                324,301   created 2026-02-03
3  affaan-m/ECC                     302,782   created 2026-01-18

It is the only 2026 new repo to pass 400k.

And note the time gap: the runner-up was created two months earlier and has 130k fewer stars.

So I can state this more bluntly:

By "stars 7 months after creation," REA is currently the #1 project in the world.

2.3 A Counterintuitive Ratio

459,260 stars
112,585 forks
──────────────
≈ 4.1 : 1

Most "viral projects" have a star/fork ratio of 20:1 or even 50:1, because many people just star and bookmark without doing anything else.

1:4 means one out of every four starrers actually forks and gets their hands dirty.

That's the dividing line between "watching for fun" and "actually using it."

2.4 But It's Also Congested

885 open PRs
837 open Issues

This is actually a bottleneck signal, not necessarily a healthy one.

mermaid diagram


Chapter 3: Why I Picked This Instead of Others

The 2026 AI coding landscape isn't short on projects. Continue, OpenHands, Roo Code, Aider, plus new agent frameworks every week.

I evaluated a few. In the end I invested my time in REA, and the reason wasn't "it's the most popular."

My Criteria

mermaid diagram

Its Actual Performance on These Five Dimensions

Engineering quality: extremely high and verifiable.

Each submission I make has to pass these:

npm ci                    # locked dependencies
npx tsc --noEmit -p .     # full type check
npm run lint              # 0 errors
npm run knip              # dead code / unused exports
npm run format:check      # oxfmt
npm run docs:check        # doc consistency

CI is also split into lanes. When I touched hopper code, I triggered:

apple-artifacts:
  name: Real Apple artifact CLI/MCP E2E
  runs-on: macos-15
  timeout-minutes: 15

I actually tripped on this once: that job ran 15 minutes 23 seconds, got killed by its own timeout, and GitHub recorded it as cancelled, not failure.

I first assumed it was a concurrency cancellation, spent a while investigating, and only when I looked at timestamps did I see: started 10:24:57, completed 10:40:20, exactly 15:23.

These details are only visible to someone who has submitted dozens of PRs inside the project.

Review strictness: my #1 reason for staying.

The project's Review Bot posts opinions minutes after you push, and often several P1/P2 comments at once. I initially treated it as noise.

Then I counted: I have 21 unresolved comment threads across 7 PRs. One PR accumulated 54 comments.

It never says "you're wrong." It says:

When a crafted link has no LinkInfo and records https://example.test/app.exe. in RelativePath, targetPaths makes that raw value the first target and this fallback strips the terminal dot, publishing .exe; an HTTP target preserves that dot and can address a different resource.

It constructs a concrete input → traces it through my code path → gives me a concrete output → and shows that output doesn't match reality.

It doesn't make a judgment first; it only lays out the evidence.

Maintainer response: slow but real.

The median merge time across my 37 PRs is 18.7 hours. And PRs linked to issues are clearly faster:

PRs with issue link     median 5.8h
PRs without issue link   median 8.2h

Why Not the Other Projects

I'll cite one verifiable criterion: look at the actual merge rate for external contributors.

mermaid diagram

The external share in REA is 5%.

That's a real problem, and I'll admit it. From a pure ROI standpoint, it's not an ideal target.

But I stayed for a very specific reason:

Every one of that 5% was merged because the code itself was correct. None got in through connections.

There's a person called Plastic-time, who, like me, is CONTRIBUTOR with push = false. Their 36 PRs were all manually merged by the repository owner; they never merged any themselves.

Inside that 5% channel, the rules are clean.

That's the basis of my judgment.

Chapter 4: Four Rounds

In Chapter 3 I said the review is strict. Chapter 4 completes that story.

4.1 One Change, Four Ways to Die

I had a Windows shortcut parsing PR. The fix: Win32 strips trailing dots and spaces from path ends.

It originated from a .lnk file where the icon path was the target path plus a trailing dot. REA compared character by character, judged them "not equal," and output:

icon_location_differs_from_target = true

How would downstream interpret that field? "This shortcut is disguising its icon."

That's a security signal.

The truth: they point to the same file.

I verified locally:

Test-Path 'C:\Windows\System32\shell32.dll'      → True
Test-Path 'C:\Windows\System32\shell32.dll.'    → True    ← same file
Test-Path 'C:\Windows\System32\shell32.dll '    → True    ← same file
Test-Path 'C:\Windows.\System32\shell32.dll'    → True    ← same file
Test-Path '\\?\C:\Windows\System32\shell32.dll.' → False   ← device path skips normalization

The code didn't compute wrong—the two strings are indeed unequal. But the conclusion was wrong: it reported a security threat that doesn't exist.

4.2 Then I Was Rejected Four Rounds in a Row

mermaid diagram

Only after four rounds did I understand:

I had been patching according to "text content," while the correct criterion is "writing style."

Filesystem paths that Win32 opens are written with backslashes (C:\… or \\server\…). URLs keep forward slashes. And //example.test/… collapses to look exactly like a UNC path—only the original writing distinguishes them.

4.3 But My First Version Was Still Wrong

My first rule was: "Only paths written with backslashes are filesystem paths."

It was immediately caught by an existing test:

expect(await iconFor("C:/Tools/bin/../\\app.exe", "c:/tools//app.exe"))
  .toBe(false);

c:/tools//app.exe uses forward slashes, but it is a filesystem path—Windows accepts both.

So the rule had to be split into two:

mermaid diagram

Six constraints, compressed into two lines of judgment.

That's the real cost structure of a "small change" in this project: small line count, high constraint density.

Chapter 5: Three Things That Hit Me When I Walked Into the Codebase

Shock One: It's Not Complex, It's Verbose

I expected a project with hundreds of thousands of stars to look like the Linux kernel—template metaprogramming, hundreds of layers of abstraction, "black magic" I couldn't read.

When I opened the first source file, I froze.

None of it. Nothing like that.

What actually shocked me was the comments.

Take this function, which does six lines:

// In `u` mode a well-formed surrogate pair is one code point outside this
// range, so the class matches only unpaired surrogates.
const UNPAIRED_SURROGATE_PATTERN = /[\uD800-\uDFFF]/u;

/**
 * Reject unpaired UTF-16 surrogates without advertising a pattern.
 *
 * ECMA-262 spells the surrogate block only as `\uD800-\uDFFF`. RE2 has no `\u`
 * escape and Rust's `regex` and `jsonschema` crates refuse non-scalar code
 * points, and a client that cannot compile one advertised pattern refuses the
 * complete tools request rather than the affected call. The issue keeps the
 * `invalid_format` regex shape an advertised `.regex` raises, so input issue
 * projection still reports `message`.
 */
export const rejectUnpairedSurrogates = <Schema extends z.ZodString>(
  schema: Schema,
  message: string,
): Schema =>
  schema.superRefine((value, context) => {
    if (UNPAIRED_SURROGATE_PATTERN.test(value))
      context.addIssue({
        code: "invalid_format",
        format: "regex",
        message,
        input: value,
      });
  });

That comment block explains:

  • why you can't just use .regex() directly
  • why it's a RE2 limitation
  • why Rust's regex / jsonschema crates reject non-scalar code points
  • why a single client failing to compile causes the entire tools request to be rejected, not just one call
  • why the invalid_format error shape must be preserved

A six-line implementation with 15 lines of "why it can't be written any other way."

mermaid diagram

The complexity isn't in the algorithm; it's in the density of constraints.

Shock Two: The Schema Is the Product

This completely rewired my understanding of "writing AI tools."

I used to think prompts were prompts and code was code.

In REA, that's not true. The JSON Schema of every tool is the entire semantics you deliver to the model. There is nothing else.

I remember one data point:

// Moonshot's function-calling API rejects requests while any single tool
// parameters schema exceeds its literal serialized size cap. Community
// measurements bound the cap between ~13.7 KB (accepted) and ~15 KB
// (rejected); 13 KiB leaves margin under the lower bound.
export const COMPACT_INPUT_SCHEMA_BUDGET_BYTES = 13 * 1024;

A third-party API's 13.7KB limit directly determines this project's schema design.

And it's a toggle:

export const resolveMcpInputSchemaProfile = (
  profile: McpInputSchemaProfile | undefined,
): McpInputSchemaProfile => profile ?? "compact";

compact has been the server default since October 22.

Then the chain begins:

mermaid diagram

One default-value change ripples all the way to "user configs are judged stale."

My PR that fixed that part deleted the function and its two consumers:

Omitting a setting that equals the default is "consistency," not "stale."

Shock Three: Most Bugs Are Not Code Bugs

This is the most paradigm-shifting thing I learned.

In traditional software, a bug is "this code computed wrong."

In REA, a large share of bugs are: the code computes entirely correctly, but its model of the world is wrong.

Back to the shortcut example:

mermaid diagram

mermaid diagram

So in this project's PR descriptions, you see not just "what I changed," but:

  • measured data tables
  • authoritative documentation references
  • before/after comparisons
  • which cases stay the same

"What stays unchanged" is as important as "what changes." That's the first engineering discipline I learned in this project.

Chapter 6: A Day in the Life of a Contributor

The Real Loop

mermaid diagram

Three Real Feelings

Feeling One: CI lanes are partitioned. Your diff decides how long you wait.

mermaid diagram

Feeling Two: The biggest pitfall isn't code; it's "branch out of date with fixed main."

Two of my PRs showed red Source tests for days. I thought it was my code's fault and spent ages debugging.

Turns out: the 3 failing tests were in JavaScriptAnalysisWorkerServer.test.ts—I never touched that file.

I checked further—main itself was red at the same time. Upstream fixed it at 14:17, but my branch was behind by 41 commits, still carrying the old failure.

After rebasing onto latest main, the same test passed locally with 6 passed.

mermaid diagram

I added this to my notes: red CI has three causes—code bugs, flakes, and "branch behind fixed main." The third is the easiest to misjudge as the first.

Feeling Three: Sharing a branch with someone is far more dangerous than opening a new PR.

I had a PR on a shared branch with the repository owner. Their 13 commits, my 13 commits—26 commits all lived only on that branch. None reached main.

mermaid diagram

That branch now can't be rebased—conflict from the very first commit, because that file was later rewritten by another 44-file PR (+2084/−603).

That's the most expensive lesson I learned in this project.

Chapter 7: Why a Small Change Requires Four Rounds of Discussion

This is the chapter I most wanted to write, and no one else could.

How Many Constraints Does One Path Comparison Need

My +184/−6, two-file PR fixed "Win32 strips trailing dots and spaces from path ends."

It looks like a .replace(/[. ]+$/, "") after path.replaceAll("/", "\\").

But actually it needs these constraints:

mermaid diagram

Three Rules I Learned

Rule One: Falsify yourself first.

Before saying "this is a bug," construct a counterexample that makes your explanation fail. I didn't do that with the V8 PR, and the machine caught it.

Rule Two: Distinguish "wrong computation" from "wrong output."

Code that computes correctly but concludes incorrectly is more dangerous than code that computes incorrectly—because it looks right. A large share of bugs in this project belong to this category.

Rule Three: Write down "what stays unchanged" in your PR.

A PR that only lists "what I fixed" gives readers no way to judge whether you introduced regressions. A PR that says "the table below remains the same" lets readers see your boundary at a glance.

A Fourth, About Code in the AI Era

In this project, I finally separated "I verified this" from "the way I verified is correct."

My original evidence was cachedDataRejected === false. In practice, V8 returns false even for truncated corrupted files.

In other words, my verification method itself was invalid, and I had no idea.

That's the moment I understood why this repository's code is full of those comments.

"This works because I did this" and "this works because everything else is impossible" are two completely different kinds of knowledge. The former gets erased by time; the latter doesn't.

That's the biggest impact REA had on me: in a field where everyone rushes to deliver conclusions, it insists on proving the way conclusions are reached.

Conclusion

37 PRs, #10 ranking, a project at #4 globally—all of these are dynamic snapshots.

rea is currently 132 stars away from #5. I'm tied with an automated account at 37 commits. These numbers will look different next week.

Only three things survive time:

  1. Its way of verifying problems—construct a counterexample first, then conclude
  2. Its habit of writing constraints into comments—explaining "why it can't be any other way"
  3. Its insistence on not integrating unsolved problems—even at the cost of 885 open PRs

If you remember only one sentence from this season, I hope it's this:

In a field where everyone rushes to deliver conclusions, a codebase that insists on proving its own way of concluding is the most worth reading.

In Season 2, we start with those 885 open PRs.


Data as of 2026-11-14. Star counts, rankings, and PR merge counts are live snapshots; they will change.