The Unbundling of GitHub Is the Biggest Opportunity in Developer Tools

Every dominant platform is a bundle that made sense at the time. GitHub bundled code storage, pull requests, code review, CI/CD, and issue tracking into one place, and it won because that bundle fit how software actually got made: humans typing code, opening diffs, reviewing each other’s lines, and gating it all behind a pipeline. The unit was the commit. The center of gravity was the diff. Everything in the bundle orbited a human author writing code by hand.

That assumption is breaking. When an agent can one-shot a well-specified change, the author isn’t a person typing line by line anymore. And once the author changes, every layer that was built around the old author comes loose. We think the unbundling of GitHub is the single biggest opportunity in developer tools right now, bigger than any one feature, because it’s not a feature. It’s the workflow getting rebuilt from the ground up.

Here’s how we see it.

The bundle was designed around a constraint that’s disappearing

GitHub’s layers each solved a human-throughput problem.

Pull requests existed because a human wrote a batch of changes and needed a checkpoint before those changes touched the mainline. Code review existed because humans make mistakes a second human can catch by reading the diff. CI/CD existed to automate the parts of verification that were too tedious for people to run by hand. Issues existed to queue work for humans who could only do one thing at a time. Code storage, the repo itself, existed as the shared substrate the whole team checked out onto their laptops.

All of it is downstream of one fact: a person sits down and types the code. Drop the cost of building to near zero and that fact stops holding. The diff is no longer the precious, slow artifact you protect with a review gate. The bottleneck moves off the build entirely, and lands on the spec, the plan, and who needs to know. The bundle was optimized for the wrong constraint. That’s what makes it an opportunity.

Each layer comes loose, and gets rebuilt around the spec

The interesting thing about an unbundling is that the pieces don’t disappear. They get re-formed around a new center of gravity. In our world that center is the spec, not the diff.

Code review. Reviewing a diff line by line was the right move when a human wrote those lines and another human had to catch their mistakes. When an agent builds from a spec, the meaningful review happens earlier and higher up: did we align on the right spec, the right design, the right architecture? Catch it there and the diff is a formality. Review shifts from “read every line after the fact” to “agree on the plan before a line exists.” The diff still gets checked, but it’s no longer where the thinking lives.

Pull requests. The PR was a checkpoint built around a human’s batch of work. The real PR now is the plan and the spec the agent runs against. Lightsprint still produces a production-ready pull request at the end, because that’s how code lands safely, but the PR becomes an output of an aligned spec rather than the place the work gets negotiated.

CI/CD. Pipelines were built to verify human work on a human cadence. When agents build and verify continuously, in the cloud, against a live preview, verification stops being a gate you wait at and becomes part of the build loop itself. You see the change take shape and you see it working in the same view, instead of pushing a commit and waiting for a status check to come back green.

Issues. The ticket was a label pointing at where the real work happened somewhere else, on someone’s machine. When the work moves to the cloud, the ticket becomes the place the work actually happens. You open it and the plan, the spec, the agent’s progress, and the live preview are all right there. The queue-a-human-for-later model gives way to the work running the moment the spec is aligned.

Code storage. The repo stays. Git isn’t going anywhere as the source of truth. But the repo stops being the thing you check out onto one laptop to participate, and becomes a shared substrate anyone can open in the cloud, human or agent, without a setup ritual that quietly decided who got to be in the build.

Why this is the biggest opportunity, not just a better feature

Plenty of companies are building a faster code reviewer, a smarter CI, a better issue tracker. Those are real, but they’re optimizing inside the old bundle. They assume the human-author workflow holds and just speed up one station on the assembly line.

The larger move is that the assembly line itself is being redrawn. When the author changes, the whole sequence, plan, spec, build, verify, review, ship, gets re-sequenced around the spec. That’s a platform-level shift, not a feature, and platform shifts are where the largest companies get built. GitHub didn’t win by being a better FTP server for code. It won by being the right bundle for how software was made in its era. The opportunity now is to be the right workflow for how software gets made in this one.

Where Lightsprint fits

We’re not trying to bolt an agent onto the old bundle. We’re building the workflow the unbundling implies.

In Lightsprint, the spec is the work. You describe a change in plain English, you align on a plan that pins down the design and architecture, and the agent builds against that spec in a cloud environment, spawning subagents per surface (frontend, API, migration) while keeping the task whole. You see visual options styled to your actual app, you watch the change take shape against a live preview, and what comes out the other end is a production-ready pull request. The review that matters happens on the plan, up front, where rework is cheap. The build is the formality it should be.

That’s the unbundling, reassembled. Code storage stays as the source of truth. Review moves to the spec. CI folds into a continuous cloud build loop. The PR becomes an output instead of a negotiation. And the issue stops pointing at the work and becomes the place the work happens, out in the open, where the whole team can gather around it instead of disappearing into a hundred private chat windows.

GitHub was the right bundle for the era of humans typing code. That era is ending. The workflow built around the spec is what comes next, and that’s what we’re building.