GitHub Overwhelmed! OpenAI Buys Alternatives, Company A Goes Solo, and Musk Joins In

GitHub Overloaded! OpenAI Acquires Alternatives, Company A Develops In-House, Musk Also Wants to Get In

GitHub, why are you having issues again…

On November 3, the official status page recorded two incidents in one day, one of which affected Git operations.

On the 4th, merge request services experienced issues again, with some requests failing or delayed.

The code is fixed, and I want a colleague to review it for merging into the main project, but it’s stuck at this step.

Some netizens also made jokes about it:

Just going for a cup of coffee.

While GitHub was busy with emergency repairs, Axios issued an exclusive report:

OpenAI plans to acquire Pierre, a code‑hosting tool, pending deal closure.

These two messages collided, the timing is quite coincidental.

And it must be said, several companies that make AI programming tools have actually started managing code themselves.

Elon Musk’s Cursor now allows developers to store an entire project directly within Cursor.

Anthropic takes it further by moving its engineers’ daily primary codebase into its own in‑house system.

Why are several companies starting to tinker with this?

Because AI is writing code faster and faster, the infrastructure is gradually falling behind…

OpenAI built one itself and is planning to buy another

OpenAI itself has experienced the feeling of its codebase falling behind.

In March of this year, The Information reported that OpenAI engineers repeatedly encountered GitHub service outages, and the company is developing internal replacement tools.

On November 2nd—just a few days ago, it opened its Git backendPando, which handles internal code storage and retrieval operations.

According to the engineering team, previously an engineer would push one change at a time. With Codex, one person can prepare several changes simultaneously.

And each time code is pushed, multiple automation tasks are triggered to fetch the code and run checks.

The number of people writing code hasn’t suddenly multiplied severalfold, yet the system’s workload has increased.

The original system gradually became sluggish, with fetching and pushing slowing down, and merges also failing.

Pando started handling real development traffic in April. According to OpenAI’s statistics, after the switch, the median time for a single push dropped by nearly 80%.

Our engineers solved the issue, and for Codex users, OpenAI is also preparing to acquire Pierre, bringing code storage and other capabilities into the product.

Come to think of it, you may have already used Pierre’s stuff~

Suppose you ask Codex to fix a bug, it changes five files in one go.

You open the file list, find one of them, and then compare line by line what it deleted and added.

The first action uses the Trees made by Pierre; the second uses the Diffs made by Pierre. These two toolsets have long been integrated into Codex.

Pierre also has a business called Code Storage, and among its customers is the AI application development platform Lovable.

Users can create a website in Lovable by entering a few sentences. In the backend, each project uses one or more Git repositories to store code and revision history.

According to data disclosed by Pierre in August this year, creates over 8 million repositories per week, with a peak of 250 per second.

OpenAI plans to wait until the acquisition is completed before bringing Code Storage capabilities into Codex.

In the future, developers will be able to have AI write code, see what changes were made, and then save that version—all potentially within Codex.

Currently, this transaction still needs to meet regulatory approval and other closing conditions.

On the day Cursor opened code hosting, GitHub also went down

Everyone may still remember that on August 14, Elon Musk’s SpaceX completed the acquisition of Cursor.

Three days later, Cursor’s code hosting service Origin opened early testing.

The result happened on August 17, and GitHub also experienced an outage lasting 7 hours 47 minutes.

Cursor employee Matt Palmer even joked at the time, basically saying they wanted to release it earlier, but GitHub—yeah, it went down again!!

Origin gives developers two options: for new projects, you can create a repository directly on Origin, push the code to Cursor, have colleagues review, receive feedback, and merge branches—all without involving GitHub.

If an existing project is already on GitHub, you can simply sync a copy to Cursor.

Comments you leave in Cursor can also be seen by teammates when they return to GitHub, and the code is still based on the version on GitHub.

Here comes the question:

Write code, review code, merge—everything can be done in Cursor, so why would I open GitHub specifically?

Even for legacy projects, the repository may still be on GitHub, but reviewers no longer need to go there.

Claude writes so fast that Anthropic built its own suite

OpenAI and Cursor have integrated more development operations into their own products, while at Anthropic, the workload has grown so large that they need to rebuild their code management system.

The main reason is that Claude writes code way too fast…

According to Anthropic’s disclosure, in May this year the company merged about 2,500 code changes per day on average. By September, a single day exceeded 30,000.

That means more than 30,000 modifications are merged into the codebase maintained by the team each day.

Just for continuous integration tasks such as automated testing, about 25 million code fetches are performed daily.

During peak periods, the company maintains hundreds of Git mirrors, using these repository copies to share the load. The faster the main repository updates, the harder these mirrors become to maintain.

Engineers have found that most of the code retrievals are performed by always‑online agents and automated tasks.

Some tasks only need to know which lines in a file have changed—why clone the repository locally first? Let the server compute it and send back the result.

Following this approach, Anthropic created Scion.

Which file the client uses, then fetch that one. For checking history, creating commits, merging changes, it’s handed over to the server.

Seven engineers used Claude, spent five months building this internal version‑control system and the accompanying code‑review tool Antique, and even migrated the company’s main codebase over to it.

However, Scion primarily serves internal codebases of Anthropic that are massive in scale and frequently changed.

Claude Code’s public repositories and other community resources remain on GitHub.

30,000 changes a day, who will check them?

After the code is fetched faster and stored more smoothly, there’s an even trickier problem:

How can we determine whether these changes are usable?

In a recent conversation, Anthropic’sAddy Osmani introduced their approach:

First have Claude perform a review round, and give it conditions, running the functionality like a real user.

For example, if the change is to a web page, open it in a browser, inspect the page, operate the features, and then run the necessary tests.

The engineer then reviews the verification evidence submitted, including operation recordings, page screenshots, and test results. Each change still has an owner, and if problems arise, the owner must address them.

△Claude Code team announces the code change review and release process

In Anthropic’s engineering blog, a more troublesome scenario is also mentioned:

During a test run, hundreds or thousands of changes may have been merged into the codebase.

At this scale, the team found that coordinating the merge queue with a repository-wide lock was hard to run effectively, so they shifted their focus to automated testing after merging and before deployment.

The company also acknowledges that concurrent changes can still cause conflicts.

They claim that Claude can usually complete fixes faster than humans discover conflicts, but no quantitative results were disclosed.

One More Thing

Reading this you might think, what about GitHub?

GitHub hasn’t been idle either; it’s also reworking its infrastructure.

On October 28, it disclosed that this year it has added 4 million CPU cores and 160 PB of high‑speed storage, and continues moving services to Azure.

In addition to adding resources, the original queuing method also needs to change.

In the past, even if several agents submitted changes on different branches, they could still end up waiting for each other at the write stage of the same repository. GitHub is enabling these updates to be processed in parallel, reducing unnecessary queuing.

△On the left, queue by the entire repository; on the right, allow updates of different branches and other references to proceed in parallel

After the code is stored, a large number of automated test tasks will retrieve it.

GitHub is also separating the resources used for reading and writing. As the number of tasks fetching code increases, they scale out the read‑only service separately to reduce resource contention between the two sides.

These changes are still being rolled out incrementally.

OpenAI and Cursor have started offering their own code hosting, Anthropic is revamping its internal systems; GitHub is also overhauling its infrastructure.

In other words, everyone is dealing with the development workload brought by AI.

As for the people we use, the requirements are actually quite simple:

The code is written, all checks are done, and when you’re about to merge it, don’t cause any issues for me…

Reference links:
[1]https://x.com/FrenchBoulou/status/2117919227147640978
[2]https://x.com/pierrecomputer/status/2117999036175188183
[3]https://www.axios.com/2026/11/04/openai-pierre-computer-github
[4]https://www.anthropic.com/research/redesigning-source-control
[5]https://www.youtube.com/watch?v=AnsXWH2_EBU

One-click Triple Action‘Like’ ‘Share’ ‘Heart’

Feel free to leave your thoughts in the comments!

— End —

🌟 Light Up the Star 🌟

Daily Updates on Cutting-Edge Tech