Blog / Article 003

How I Almost Pushed a Year's Worth of Work in One Commit

I had a plan. I'd spent more than a year working on Reliverse in a private environment, and I finally wanted to open the code on GitHub.

Plan A: one enormous commit.

Plan B: fine, maybe 10 or 20 commits. That's responsible, right?

Reality: I built a system for managing publication campaigns, then used its first campaign to publish a single Markdown file.

Yes, I see the irony too. 🫠

This is the story of GR Campaigns. Not a Git tutorial, and definitely not an argument that every project needs its own publication machinery. It's about how one particular mess became an engineering problem, and how the solution nearly became another mess.

On this page: Git wasn't the problem · What didn't belong in one giant commit · Why not just use Git branches and pull requests? · From “push everything” to GR Campaigns · Campaign001: one Markdown file · Campaign004: small, but reproducible · When your own campaigns are hard to use · What I took away from all this

Git wasn't the problem

My private reliverse working tree had thousands of changed files. Alongside reliverse, I was working privately on bleverse, bleverse-ui, rengine, and other repositories. There were libraries, CLIs, experiments, tests, documentation, new names for old ideas, and old names for things that no longer worked the same way.

Coding agents, of course, helped implement a substantial amount of it. That made experiments faster. It didn't automatically make them ready for publication. Reviewing the code and taking responsibility for it were still my job.

I kept putting off the big push, not because Git couldn't handle it. Git could. The question was what would actually land in the public repository.

Imagine someone finding a promising library on GitHub, trying to run it, and discovering that it depends on another package that isn't public yet. Or the documentation describes yesterday's API. Or half the configuration only makes sense on my VPS.

Technically, the code is public. Practically, nobody else knows what to do with it.

That's what I wanted to avoid.

I'd already seen how a project could change its own identity. The repository now called reliverse/experiments preserves traces of several generations of Reliverse, from a 2023 Next.js starter to a CLI, Rse, and later prototypes. Those old commits are valuable history. That doesn't make everything inside them a supported product today.

What didn't belong in one giant commit

The problem wasn't just file count. There were different kinds of risks:

  • Dependencies. A public component needs a realistic way to run, or clear limitations when there isn't one.
  • Transitional decisions. Not every experiment or retired contract should be presented as a supported API.
  • Internal material. Private notes, agent work traces, and environment-specific paths shouldn't accidentally ship in the public repository.
  • Verification. A successful local commit doesn't prove the expected result reached GitHub.
  • Permissions. An agent preparing changes shouldn't automatically get permission to publish them.

Some of my specs had grown to thousands of lines. I also had tests that carefully checked heading capitalization without being nearly as helpful at proving the behavior that mattered.

I didn't want to throw code over the fence and check the "open source" box. I wanted the next person to understand what they were looking at and how to verify it.

Why not just use Git branches and pull requests?

Fair question. For plenty of projects, a branch, a handful of meaningful commits, CI checks, and a pull request are more than enough. I don't think GR should be a prerequisite for ordinary development.

My problem wasn't the git push command. It was a large private working tree, packages in very different stages of readiness, several related repositories, and agents that could prepare changes without automatically having permission to publish them. I wanted a way to define the scope of an operation and verify the result afterward. GR grew out of those particular constraints.

Of course, having a good reason for a system doesn't justify every abstraction I managed to invent along the way.

From “push everything” to GR Campaigns

Eventually I settled on a simpler idea: publish bounded, reviewed pieces, not the entire working tree at once.

That became GR Campaigns. Across different iterations, they helped answer questions like: what exactly are we opening, which dependencies are required, what passed verification, who authorized publication, and did it actually happen?

Inside, that meant plans, candidates, checks, authorization, execution results, and remote readback. Some early versions had extra machinery that I later had to revisit.

But the underlying idea stayed simple:

Preparing a change, authorizing publication, and verifying what reached the remote repository are three different steps.

Just because they can fit behind one button doesn't mean they should be confused with one another.

Several tools are involved around the edges. GR deals with Git and campaigns, RPR with packages, and RVS with authorized operations in an environment. There's RDG for deployments. None of that should become mandatory baggage for someone who just wants to inspect their Git status.

Campaign001: one Markdown file

The first symbolic campaign was Campaign001. It published OPEN-SOURCING.md.

One file.

After a year of work, thousands of changes, and all that infrastructure, it was an almost comical ending to act one. I still think it was the right move: a small change was easier to review, and the publication itself was easier to verify on GitHub. Of course, one published file does not exercise every GR Campaigns workflow.

Next came bootstrapping the public repository and gradually opening real code. Campaign003, for example, brought public foundations for RVS, DCS, and Gatehouse. Important building blocks, yes, but not necessarily finished products that anyone could install and use immediately.

And that's where my definition of progress changed.

"Look, we've opened more code" stopped being enough. I wanted one thing a stranger could actually reproduce on their own machine.

Campaign004: small, but reproducible

That's how the public read-only GR source inspection example appeared in reliverse/reliverse.

From the root of a cloned repository:

bun --no-install --no-env-file examples/gr/inspect.ts .

It shows the Git HEAD and counts of staged, unstaged, untracked, and conflicted changes. It doesn't require installing the full GR CLI, doesn't commit or push anything, and doesn't need access to my VPS.

There's also a focused test and a GitHub Actions workflow for the example:

bun --no-install --no-env-file test examples/gr/inspect.test.ts

The public example and test files are there for anyone to inspect. Running them requires Bun and Git; the result depends on your environment and the repository's state. A committed test file is not proof that it will pass on your machine. This isn't a release of the entire GR system or a universal “everything works” badge.

But it is a concrete public scenario, not just another package name on a list.

That difference matters to me.

When your own campaigns are hard to use

There's a less heroic part to this story.

I built controlled workflows because I didn't want to publish the wrong changes by accident. But sometimes even I struggled to get through all the technical steps of my own workflow.

Plans, checks, internal operations, approvals, results. Every piece seemed to have a reason to exist. But the fact that I kept looking up the correct sequence of internal steps was already a sign that the interface wasn't doing its job.

So I started improving the GR Campaigns workflow through the RVS Browser App too. I want to see a plan, review upcoming changes, understand where an operation stands, and move to the next step without manually reconstructing every internal command.

Instead of “open this internal file, run that command, and don't forget the next script hiding in temp,” I want a proper view of the plan and the operation's state. The UI is still evolving. I'm not presenting it as a finished universal solution. But I like the direction: complexity stays where it protects the process instead of becoming a daily chore for the person using it.

That's also where my next big argument with myself and my AI agents began: does every new abstraction really need to exist? More on that in Article 005 (planned for 2026-11-20).

What I took away from all this

Git didn't suddenly change. I just stopped treating one big push as the same thing as a good open-source release.

Now I try to imagine someone opening the repository for the first time. What can they see? Can they tell what's ready? Can they reproduce one example? Is it obvious what's still missing?

And I don't want to measure openness by file count. Five hundred files that nobody can use aren't automatically more valuable than one tiny working example.

That leads directly into the next article (planned for 2026-11-18): how to show what's genuinely open and usable without asking people to take my word for it.

My personal takeaway is even simpler. Sometimes the best result of a lot of engineering work isn't a massive release. It's one small thing you can finally share without first explaining your VPS.

Back to top

Author: blefnk · Language: English · Series: Introducing Bleverse

Previous article · All published articles

Built with BVF and UIR. No account required. RSS · GitHub · Community