GitHub rewrote 800,000 lines of Copilot in Rust, and AI wrote most of it

😁 Hello, super humans! Saturday’s story is a rewrite that would normally be a multi-year project, finished in about a quarter and mostly typed by AI agents. The interesting part is not that it worked, it is how GitHub kept it from falling apart. We also have a robot hand with no pinky, a chip process that skips EUV, and a very big check for some radio spectrum.

📰 Quick Signals

• 🧠 AI: Manus raised more than $500 million, led by Boyu Capital and IDG Capital, after Meta’s planned acquisition was cancelled when Chinese authorities blocked it.
• 🤖 Robotics: Boston Dynamics’ redesigned Atlas hand has four fingers and 13 identical, fully encapsulated actuators; the pinky is gone to cut cost and size for mass manufacturing.
• 💻 Programming: Shopify rewrote five checkout UI extensions with Preact and Polaris web components, cutting bundle sizes by up to 85%.
• ⚡ Electronics: GlobalFoundries unveiled FDX Fusion, a strained FD-SOI process aiming at 7-nm-class digital performance without EUV lithography, with demonstrator silicon targeted for early 2027.
• 📡 Telecom: SpaceX agreed to buy 14 MHz of paired 800 MHz spectrum from Grain Management; the price is undisclosed, though the Wall Street Journal reported about $8 billion in cash.

🔍 The Big Story: GitHub rewrote 800,000 lines of Copilot in Rust, and AI wrote most of it

If your team has a big legacy codebase and a deadline-shaped hole in your roadmap, this is the most detailed public playbook yet for letting AI agents do the typing without losing control of the result.

What happened: GitHub migrated the runtime behind Copilot CLI, the Copilot app, and the Copilot SDK from TypeScript and Node.js to Rust. According to InfoQ’s write-up of the GitHub engineering post, the work replaced more than 800,000 lines of production code in about 14.5 weeks, shipped through 128 pull requests, while the team kept releasing: 135 releases along the way, 35 stable and 100 prerelease.

The details: The old design needed Node.js and V8 and talked to host applications across a process boundary, which GitHub says cost about 100 MB of working set per client. The new Rust runtime can be embedded directly in a host application through a C ABI, with an out-of-process mode still available. In one measured scenario (client startup, session creation, and a single turn), time dropped from 5.25 seconds to 292 milliseconds, roughly 18 times faster. The method matters more than the speedup. GitHub did not build a parallel rewrite and cut over once. It replaced components one at a time, bridging Rust and TypeScript with a temporary N-API layer that peaked at 2,019 internal exports and 3,356 TypeScript call sites before being deleted, and it kept the existing end-to-end tests running against the mixed system. AI agents generated most of the implementation; compilation, tests, and human review caught what they got wrong. GitHub logged 4,478 direct cargo check runs, and 87.1% passed cleanly, which also means about one in eight did not. By August 21 the runtime held 832,378 lines of production Rust plus 468,689 lines of Rust unit tests, and reviewers still found regressions in behavior, state and lifetime handling, library semantics, and lost optimizations.

flowchart LR
    A["TypeScript runtime<br/>Node.js + V8"] --> B["Replace one component<br/>with Rust (AI-generated)"]
    B --> C["Temporary N-API bridge<br/>Rust <-> TypeScript"]
    C --> D{"E2E tests + human review<br/>pass?"}
    D -- no --> B
    D -- yes --> E["Ship (35 stable, 100 prerelease)"]
    E --> F{"More TypeScript left?"}
    F -- yes --> B
    F -- no --> G["Remove bridge<br/>Rust runtime, C ABI embed"]

🗞️ More News

🧠 AI

• Google released AI Edge Foresight, an experimental local meeting-notes app for Mac that transcribes meetings and answers questions offline using the on-device EmbeddingGemma 2 model.
• Claude can now edit open files in Google Docs, Sheets, and Slides from a sidebar, in public beta on all paid Claude plans.
• Investor documents reportedly put OpenAI’s annualized revenue run rate at about $50 billion at the end of September, well below the roughly $70 billion that had circulated, according to the Financial Times.
• Amazon blocked Meta’s Muse shopping agent, saying it did not identify itself properly and raised data and authentication concerns, while Shopify is allowing agent purchases through Shop Pay.
• Texas froze new data-center permits after its queue of large power customers grew from 63 GW to 474 GW, with new rules adding a $100,000 study fee and a $50,000-per-MW deposit.
• Nolla Health will pilot AI-issued prescriptions for mild to moderate acne in Utah, limited to topical treatments for adults, with two doctors reviewing every prescription at first.
• OpenAI Verify is a free tool that checks whether an image or audio file came from an OpenAI system; the text detector is not public.

🤖 Robotics

• Uber and Pony.ai plan to start London robotaxi tests with the Pony.ai Gen-7 within weeks, as Uber aims for autonomous rides in up to 15 cities by the end of 2026.
• The Robot Report argues humanoid demos still fail the generalization test, and that better data and human judgment are what move them toward dependable real-world work.
• Groceryshop 2026 put inventory robots and wider retail automation on show, with coverage suggesting retail robots are ready to scale and use AI.
• Interact Analysis says Schneider Electric’s PTC acquisition creates a design-to-operations data thread that could challenge Siemens, though integration work remains.

💻 Programming

• Google’s Android Bench 2 adds long-horizon tasks, agent-based evaluation, and continuous scoring for AI models on Android development.
• Valkey, the Redis fork, is expanding beyond caching, with planned features such as synchronous replication and tiered storage, according to a talk at OSS EU.
• The Google Cloud Terraform provider reached 8.0 in general availability, changing default load balancing behavior and removing resources for retired services.
• A survey commissioned by Undo finds AI coding agents speed up writing code but shift the bottleneck to debugging and comprehension.

⚡ Electronics

• Researchers turned soft silicone sheets into three-dimensional shape sensors using roughened optical fibers.
• Rohm is expanding its back-end chip manufacturing outsourcing and R&D in India while keeping wafer fabrication in-house.
• Raspberry Pi is running its own boards with Home Assistant as it plans a path to net zero.
• A builder made a belt file from an old mixer motor, scrap aluminum U-channel, and wood.

📡 Telecom

• Nokia may name a buyer for its campus private networks business as early as its October 22 third-quarter results, with a resolution promised by the end of 2026.
• Amdocs signed a 10-year deal to run and modernize VEON’s core technology operations, and may fold VEON’s QazCode LLM technology into its aOS agentic operating system for telcos.
• T-Mobile’s CTO says he welcomes SpaceX as a possible new U.S. wireless competitor.

👨‍💻 Code Corner

GitHub’s headline number is a startup-time drop, and the habit worth stealing is measuring it before and after every change. This script reports the median wall-clock time of any command over several runs, so you can compare a Node script with its Rust replacement.

import statistics
import subprocess
import sys
import time


def bench(cmd: list[str], runs: int = 10) -> float:
    """Median wall-clock seconds to run cmd to completion."""
    times = []
    for _ in range(runs):
        start = time.perf_counter()
        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
        times.append(time.perf_counter() - start)
    return statistics.median(times)


if __name__ == "__main__":
    # Usage: python bench.py node app.js   (defaults to an empty Python run)
    cmd = sys.argv[1:] or [sys.executable, "-c", "pass"]
    print(f"median over 10 runs: {bench(cmd) * 1000:.1f} ms")

Run it once on the old build and once on the new one, and you have a defensible number instead of a feeling.

🧰 Toolbox

• Sipeed SLogic32U3: A third-generation 1.4 GS/s logic analyzer from Sipeed, now open for funding.
• BIGWORDS.PAGE: A web page whose big-text display is controlled entirely through a crafted URL, handy for quick signage.
• Bambu Lab R1 CO2 laser cutter: A hands-on review after a couple of weeks of testing, useful if a laser is on your maker wish list.
• Claude Dashboards: Builds dashboards where each chart is backed by its own query.
• Claude Motion: Creates short animations and exports them as MP4.

🛠️ Build of the Week (rotating)

XGO Duck: An open-source, 3D-printed biped robot duck from Luwu Dynamics, built as a DIY alternative to Pollen Robotics’ Microduck, which is not yet available.

• Difficulty: Intermediate to Advanced (my estimate; the project does not state one)
• Parts: Arduino UNO Q, 15 FeeTech 1910 servos, a custom expansion board with a QMI8658A six-axis IMU, 3D-printed body with TPU for the feet soles and mouth, bearings, and M2 screws
• Why we like it: The hardware repo includes the schematic, PCB design, bill of materials, and assembly guide, plus a separate runtime repository with walking, get-up, and pick policies, so you can study a complete small legged robot end to end.

📚 From the Blog

• Turning Pixels Into Something the AI Can Eat: Episode 3 of the camera-to-AI series, after clean capture and network transport, on preparing pixels for a model.
• Building Your First Neuron From Scratch: Part 2 of the neural network basics, on how simple learnable transformations stack up.
• The Network Behind the Cameras: The unglamorous plumbing that moves video from camera to model.

😀 The Bot Says…

GitHub’s new runtime starts in 292 milliseconds, which is still slower than me finding a reason to rewrite my own side project in Rust.