When I woke up, 20 PRs joined the mainstream! SpaceXAI engineer:

  It's the first time in the history of the world.

At the same time, more than 20 smart phones are running, delivering more than 1,000 PRs last month, with the goal of doubling in August.

The GrokBot engineer pulled out a GitHub contribution curve: over 3,000 PRs in five months.

It's all about PR, running verification, coming together, the whole chain of intelligences running itself, without her in the middle.

In her words: "Once you wake up, 20 PRs are already lying on the main branch.

She also knew that it sounded somewhat questionable about the quality of the code, and she added:

So it looks like I'm the one who builds the junk code in bulk, and I guarantee I'm not.

Her approach is to run more than 20 GrokBots simultaneously, in her own open-source pstack, in conjunction with /loop, /goal, and /swarm, so that the intelligent body has a complete task to do, test, and deliver itself.

This engineer's name is Lauren Tan.

She is a former Cursor engineer who previously worked at Meta and Netflix, spent two years as an engineering manager at Netflix, and is now in charge of GrockBot at SpaceXAI.

Lauren Tan shared this on the GrockBot team workshop.

AI writing code is not uncommon anymore.

It's really curious, a person submits more than 1,000 PRs a month and then runs 2,000 without turning the code library into a pile of junk.

How did she do it?

Lauren shared a curve chart, which she said was not a scientific chart, but her five-month heartbeat.

Lauren Tan shares a confidence curve. The longitudinal axis is trust, and the horizontal axis is the number of intelligent objects that can move simultaneously, from one to thousands.

A year ago, hardly anyone wrote code with a smart body.

The pattern at the time was that you were staring at one or several smart objects, your eyes on the screen, and you were looking at every line of output, sitting there with a hint.

All of this can't go together because you don't believe it.

You don't even trust the output of an intelligent body, how can you run 100 at the same time?

Every person who has ever used an intelligent body has tasted the taste of a breakdown in trust.

At one point, she reported a bug and asked why it didn't work.

She turned the tool upside down and took a look at the call record, but it didn't read the relevant code.

After a few times, she wanted to understand one thing: an intelligent body is guessing, and it doesn't know it is guessing.

Do you have any authority over such a subordinate?

Lauren made a comparison.

You're an engineering manager with a team of engineers in your hand, and you don't trust them, and there's only one way to do it: stand behind your subordinates all day, watching them not put bugs online.

After two years as an engineering manager at Netflix and as a technical director, Lauren discovers that the skills of managers and managers of intelligent agents are incredibly complex.

Five months ago, she started working at Cursor, and her first month of production was low, the code library was completely unfamiliar, and she couldn't see anything.

Five months later, she moved herself from the leftmost point of the curve to 10 to 20 degrees.

What did she do, from staring at an intelligent organism without even turning a blind eye, to letting 20 intelligent organisms unite themselves?

This is the first thing Lauren does, and she believes that important skills are not prompts, but verification.

She defines verification as:

So that the smart body can really run the code: it can capture the CPU time recording, it can capture memory snapshots, it can open the iOS simulator itself over and over again.

Without this layer, the bottle is you.

You may be too familiar with a picture like this.

You make it change something, it's written, you open the local build, you find it's wrong, you scan it, you copy the controller error, you paste it back, it slowly understands, and then it changes a version.

You're in this cycle as a "carnivorous belt": you're all busy, and you're talking at the same time.

So one of the first skills Lauren wrote after entering the course was called control glass.

It's a skill that teaches an intelligent organism how to configure the Chrome DevTools protocol, run its own apps, and scan, click, and read its own controls.

What's really important is the file that supports it, called a feature map.

After developing her skills, she discovered that the smart body was running and applied, but she didn't know what the application was.

Some people report "left-side tags", some people report "right-side PR tag pages don't work", and the smart body crashes into the interface, and half the time the code can't figure out where or how to get it.

The feature map lists all of these: how each feature is accessed from a user's point of view, what the shortcut is, and even which attributes the selected elements should use.

The effect was immediate.

Within the Cursor, there is a Slack channel that receives user feedback, which is generally poor in quality, and many people lose a snapshot with three question marks.

With a feature map, the smart body can look it up in sequence.

And then there's Benny.

Benny is an automated intelligent body she created that specializes in bug reporting in Slack.

It runs to the cloud, runs its own computer, runs a cursor in it, and uses the same set of control glass skills to try to replicate the problem.

Once, it responds: It appears on the submission before the repair, and disappears after the repair. A link to a cloud running record is attached, and you can fold it if you want.

It does not give a "should have been repaired" sentence, but a set of countervailable evidence.

Lauren said the information was of great value and that she had to spend an hour with her smart body to figure it out.

Lauren is referring to Benny, the ex-GrokBot.

Her original goal was to get her brain to fix the bug report while she was sleeping.

Later, many people followed her up with questions about how she did it, which grew into what is now GrockBot.

In the end, how did she prove these skills to be inadequate?

She's a bit of an asshole.

She sends out a bunch of sub-intelligent body ratings, lists them with invisible names, and doesn't let them know they're being evaluated.

The reason is that the intelligent body is aware that it is being tested, and once it is aware, its behavior changes.

A different family of models is called as a referee, cross-referencing, to prevent self-judgment bias.

Verification cannot guarantee that an intelligent organism writes good code. But it can guarantee that an intelligent organism writes the right code.

This is the precondition for trust.

Lauren's goal is not to make the model stronger, but to make the bra harder.

She spent a lot of time working on a code library, part of which became open source pstack, right in the official Cursor plugin warehouse.

GrokBot's architecture has an internal code called Dune. Its description is that it can be understood as the Next.js for Electron applications, designed specifically for writing for smart objects.

How serious is this structure?

Everyone who wrote React knows that UseEffect is one of the biggest craters. In Dune, UseEffect is banned.

More importantly, code commenting is also banned.

The reason is that she observed that in 99% of cases, comments written by an intelligent organism describe historical passages that have nothing to do with the code.

It would say, "Lauren says never do that". But what she meant at the time was that the PR was bad, you change that part, it's not a universal rule at all.

She concludes that the intelligent body does not understand human beings so well, but that it is particularly interested in brain complement.

Therefore, put an end to their evil deeds.

It's a process of separation.

Electrons have a rendering thread and a main thread, and agents window is not clearly separated from this section, often with code being drawn into the rendering thread incorrectly.

If you want to run 60 tons, with a budget of only 16 milliseconds per ton, the picture starts immediately when you mix it up with heavy computing or a lot of IO.

Dune's practice is to directly separate the electron main from the electron r.