REBELLING AGAINST FLIPPED BITS AND THE VECTOR GRAVITY THEY CREATE

My years-long journey from better DevOps to adaptive, compositional computing

The Strange Feedback Loop That Changed Everything

For the last nine months, since Sonnet 3.5 launched and I got early access to Copilot Workspaces, I've been building toward something I call Busbar — a fully pluggable, fully declarative, fully portable delivery system for what I've come to see as the future of Composable Delivery.

Like many ideas I become passionate about, this one was incredibly abstract. But the "gut feeling" of value was the strongest I'd ever experienced. Strong enough to scare me — both about freaking people out with abstract, radical-sounding theory, and about the possibility that some well-funded team might run with my idea before I could prove it. Or maybe the scariest thought: that this idea was simply inevitable, the natural convergence point across domains like Python, Rust, Git, IPFS, NIX, and AI.

Today, launching this blog, I'm confident enough in the proof I've been building to share it. I've been fighting what I call "vector gravity" — the intense, black-hole-like pull of conventional patterns in both my own programming experience and my AI sidekick's training set — to arrive at something fundamentally different.

Who Am I, and Why Should You Care?

I'm Jason, and this blog exists because of a Strange Feedback Loop that put me at the intersection of forces rarely found together in technology.

I spent twelve years as a refractive mirror in one hell of a feedback loop: Benioff's $1.2B donation of enterprise platform licenses to the nonprofit sector, my own journey leaving the Innocence Project to join Salesforce because of the scale of impact possible, delivering community-built open source from GitHub through the AppExchange to 50k nonprofits, all while building the tools and patterns to make it work.

That wasn't just a job—it was a Strange Feedback Loop, a weird combo of factors quite unique in the enterprise platform space. It placed me at the exact vantage point needed to see distortions in how we think about software delivery that remain invisible to most.

Vector Gravity: The Force That Shapes Our Thinking

"Vector gravity" is my term for the relentless pull that conventional programming patterns exert on both human and AI reasoning. Just like physical gravity, it warps the space around solutions, making it almost impossible to see alternatives. The stronger the pattern's presence in training data or muscle memory, the stronger its gravitational field.

This vector gravity isn't just annoying — it's what causes what I call the Fidelity Gap: that moment when meaningless data bleeds into a supposedly formal system, creating noise and errors that everyone then covers up with increasingly elaborate brute-force solutions. The Fidelity Gap is the flipped bit in a domain's theory, missed by everyone except in its side effects.

Think of flipped bits as foundational assumptions that are exactly backwards—creating ripple effects throughout entire fields of thinking. Like the assumption that software and systems are synonymous, when they're fundamentally different. Or that configuration must be separate from code, when they're really just different expressions of the same patterns.

The Journey from Revolution to Rebellion

In The Rebel, Camus distinguishes between rebellion and revolution. The revolutionary seeks to invert power structures—to become what they oppose. The rebel rejects the system entirely, refusing its terms.

I've spent years being a rebel, but it took me a long time to understand why.

My path wound through many waypoints: discovering that delivery patterns themselves are products (not the artifacts they produce), nearly building my own platform prison when I thought I was revolutionizing the industry, then realizing the solution was already there in how GitHub could be used differently.

But the real insight came when I recognized that our entire approach to "state" in computing is fundamentally flawed. When Descartes mapped mind onto a coordinate grid, he doomed software to state explosion. We've been trying to manage complexity by cross-multiplying independent variables, when the answer lies in composition and context.

The Cartesian Trap and the Path Beyond

Every program we write treats state as a Cartesian product — a cross-multiplication of independent variables. Add features, scale complexity, and suddenly we're managing exponential state spaces that inevitably collapse.

But what if we're thinking about this completely wrong? What if state isn't something to be managed but something that emerges from relationships and context?

This realization led me to what I'm calling Composable Delivery—a way of thinking about systems that can compose, adapt, and evolve across trust boundaries. Not just thought experiments, but computational reality.

Composable Delivery: The System Inversion

This journey crystallized into what I call Composable Delivery—a complete rethinking of how we deliver living, evolving systems.

The insight: delivery is about systems, not software. It's based on patterns, not artifacts. And it must be composable, adaptable, even adaptive.

What I found was the need for a fully portable declarative system, one capable of securely and deterministically adapting system contexts. The key to traversing enterprise trust boundaries. The escape from my platform prison.

I just had to invert the architecture entirely into a portable system. Nine months in Rust proved this isn't just philosophy. Three core principles:

1. Everything is declarative — patterns over procedures
2. Context is explicitly typed — meaning travels with data
3. Composition is safe by design — like patching modules

The result? Systems where:

• Configuration and code co-exist as versioned patterns
• Deployment is hash verification
• The rules that compose a system live inside the system itself
• A YAML file can bootstrap an entire computational context

Composable Delivery is itself a rebellion, not seeking to invert control to the receiver but instead to create a new kind of system where cross boundary relationships could "live" as in, be delivered, adapt, and evolve as a distributed delivery network. It's about Agency for both sides.

Sure, you can have full control and build millions of Docker images a day for your internal systems to be "composable." But wouldn't secure runtime adaptation from mutually understood and trusted declarations of context perhaps make more sense?

This isn't an either-or, but imagining a fully runtime composable declarative system is a great thought exercise to check for the vector gravity of the flipped bit of state.

OK, One Last Bit of Philosophy...

I think Vector Gravity is pretty similar to Heidegger's concept of Lichtung (clearing). Heidegger wrote:

"The clearing is the open region in which something can appear, can show itself, can come into its own... What is lighted is what emerges from the dark."

Vector gravity creates epistemological shadows—places where solutions remain hidden in the "dark" created by conventional patterns, visible only to those who step into a different clearing. The constraint is placed by theory not grounded in the actual relationships between things.

Beyond Platforms, Beyond Constraints

This journey has taught me that our most fundamental technical constraints are often philosophical assumptions in disguise. Vector gravity keeps us from seeing alternatives that are hiding in plain sight.

The rebellion isn't about replacing one technology with another. It's about recognizing that the boundaries we think are fundamental—between code and configuration, between static and dynamic, between system and software—are often just flipped bits creating artificial constraints.

Now, reflecting on the journey that started building my own platform prison was my attempt at a revolution. I was trying to build a better Salesforce DevOps platform. It was better, even revolutionary, but the rebellion was seeing the inversion into an open platform, fully portable, natively, anywhere for anyone.

What's Coming

This blog will document my ongoing exploration of:

• How vector gravity warps solution spaces
• Why delivery must be about systems, not software
• The architecture of portable, declarative systems that adapt across trust boundaries
• The path toward truly composable, adaptive delivery

We'll trace the implications across domains—from software delivery to AI systems, from organizational design to the nature of computation itself.

But most importantly, we'll explore how recognizing these flipped bits and their vector gravity can open up entirely new solution spaces that were always there, just invisible from within the conventional fields.

Coming Soon:

• Busbar - The open-source framework for composable delivery patterns
• TypeSynth - Busbar's first module, written in Rust, demonstrating how a single YAML can bootstrap computational contexts
• Deep dives into the evolution of delivery patterns to Composable Delivery
• Real-world case studies from the field and the broader ecosystem
• The mathematics and philosophy of context-aware systems

"The rebel can never find peace. He knows what is good and, despite himself, does evil. What he wants is to die and to multiply himself, to die also to the power that beats him, and for his opposition to be no longer powerless." - Albert Camus

Fork this idea. Prove me wrong. The conversation starts now.

Connect with Strange Graph:

• Follow the journey at strangegraph.com
• Watch for Busbar and TypeSynth—coming soon on GitHub