Continuous Compounding with Agentic AI

The equation of disruption has changed. Every previous era was linear. This one compounds.

We are at an inflection point. In the industry, in our world, and personally. I've spent twelve years leading engineering organizations through every flavor of digital transformation, and I've made a career change at this moment for a reason. The time to go fast is now. Not in six months, not in a year, because by then it will be too late.

We're now at a point of exponential rather than linear progress, and therefore exponential rather than linear disruption. The potential to get exponentially ahead is there. So is the potential to fall exponentially behind. AI is enabling a compounding effect. This is not semantic; this is the difference between saving for retirement by stuffing cash in a mattress versus investing in your 401K.

Every previous era has hit the breaking point. The model hit its finite limits. The cost and complexity outweighed the benefit, and things were ripe for disruption.

The difference this time is that we are able to use AI to create AI, to improve AI, to build the next iteration of AI. With each cycle we're increasing our rate of return. With each new generation of chip and model efficiency gain, we're cutting our cycle-time. Of all the factors, that time compression is the real differentiator.

But to really see why this time is different, let's trace the pattern of disruption in software to understand each previous wave, and where the math of the new model really starts to take off.

Arbitrage: 1:1 replacement, no leverage

Labor arbitrage was largely an accounting exercise. Take manual things that were highly repeatable, medium to low skill labor, re-badge, document, train lower-cost resources, then lay off the high cost labor. It was purely a labor-market play and CFOs loved it. Experience and quality could be degraded a little bit, but overall the org would deal. The "ticket" and ticket metrics became the thing that was managed, and gamed, via SLAs. It was very transactional: tell me exactly what needs to be done, and it will be done within the SLAs.

There are a couple of interesting things here. Headcount, in most organizations and many cultures, is a symbol of power. Want to see who's got the most power in a company? Look at the org chart and I guarantee you'll subconsciously attribute power to those with the largest headcount. So labor arbitrage also had the added benefit of maintaining (or even increasing) headcount.

This model served and reinforced the established power structures. Headcount was headcount. This is where Conway's Law starts to do its work, because organizations design systems that mirror their communication structures. Labor arbitrage didn't just preserve the org chart, it encoded the org chart into the operating model. The silos, the handoffs, the narrow responsibilities, those weren't bugs, they were the power structure made operational.

The trade-offs were predictable. Highly siloed, narrow responsibilities. Gaming of the system to stay within SLAs. Ticket volumes were increased every year. No incentive to innovate. Cycle times stretched out, as each cycle resulted in a 12-24 hour delay. Cost decreased but wait and rework increased. It was also a model you could throw bodies at to improve performance.

Automation: force multiplication

The automation movement started taking shape around the time of the Agile Manifesto, and coincidentally, was being driven by many of the same people who wrote it at Snowbird.

They were smart engineers who had already been building frameworks and tooling to practice what they were preaching. They saw the bottleneck of manual testing and test harnesses, so they built unit and acceptance testing frameworks. They needed to detect breaking changes earlier, so they invented Continuous Integration.

It still took a few years for it to coalesce into what would become DevOps, but the seeds had been sown decades before with the Toyota Production System and Lean. Market success was the proof that encoding discipline into the process itself, not relying on individual heroics, was the path to quality at scale.

So as labor arbitrage was an accounting exercise, automation was an engineering discipline. One rebadged people, and kept the manual processes in place, while the latter encoded knowledge as executable code. That was the key structural difference.

Testing as code. Infrastructure as code. Observability as code. We were now able to manage our entire technology ecosystem through automation and version control.

The ticket queue started to give way to the pipeline. Quality wasn't something you checked at the end; it was something you encoded at the start. You couldn't game a CI/CD gate the way you gamed an SLA.

Each one of these advances, when adopted, had a multiplicative effect. Not just in speed and quality, but in leverage. It allowed one person to do the work of what historically would have been many individual tasks and a pile of tickets. A lever lets one person move what many couldn't. Automation was the lever.

This did come with trade-offs. It required investment and discipline. Even with hard data showing the benefits of automated testing, test-driven development, and infrastructure as code, the initial construction cost was higher. The org had to learn, and re-tool, not just rebadge. For those that did lean in, the model was incredibly disruptive, leading to the explosion of Cloud Computing, SaaS companies, and Continuous Product Delivery.

But here's what's interesting, and what connects directly back to labor arbitrage. Automation created new roles but it didn't fundamentally challenge the power structure. The org chart absorbed it. Cloud adoption using manually provisioned infrastructure instead of Infrastructure as Code. Automated test suites that replicated mouse clicks and multiple days of test data setup, resulting in a mountain of false positives from test brittleness. The promise was understood and pushed at the executive level, but at the middle management layer it died through ineffective implementation.

This wasn't accidental. These technologies threatened the headcount, threatened the power structures. You adopt the tool but not the discipline. You stand up a CI/CD pipeline but gate it with manual approvals. You write automated tests but make them so brittle they require a team to babysit. There's still a lot of "job security" built into the way many organizations implement these frameworks and tools, not because the technology failed, but because the org structure had every incentive to make sure it didn't fully succeed.

The automation era introduced real seams at the technical layer, and the foundation, but it left the organizational seams untouched. Conway's Law, again. Force multiplication is formidable, but if the organizational structure absorbs the force, you get motion without movement.

Agentic: compounding

As mentioned at the beginning of this post, the Agentic AI era is compounding, so for a simple analogy we're going to look to the person who consistently ranks around the 10th wealthiest person on the planet, Warren Buffet.

Warren Buffett bought his first stock at eleven years old. He was a millionaire by thirty, but over 99% of his net worth was accumulated after his fiftieth birthday. Not because he got smarter. Not because he found better stocks. It was because of compounding.

Buffett describes it as a snowball rolling down a very long hill: "The trick is to have a very long hill, which means either starting very young or living to be very old." The constraint is always time. You can optimize your rate of return, but you cannot speed up the clock. The hill is as long as the hill is.

That constraint is what makes the agentic era fundamentally different. In investing, compound interest rewards patience because the rate remains largely unchanged and time cannot be compressed. In the world of Agentic AI and compound engineering, we get to modify the rate and compress time. To understand why, we need two things: the compound interest equation, and the humble feedback loop.

The compound interest equation gives us the structure. Two variables, your rate and your time.

The feedback loop gives us the mechanism. The simple loop of Reason → Act → Observe is open-ended; it will continue to work on the problem until it's solved. Add a steering mechanism as part of the feedback arrow, and it begins to look very similar to the way humans work well together.

But what's different here, what Buffett never had, are two levers on the same equation. Agents don't just execute at a better rate. They compress the cycle time itself. The snowball doesn't just pick up more snow per rotation, it rolls faster, and that changes everything about what the curve looks like.

This is also why the agentic era is so profoundly unnerving, and not just for the reasons people talk about. The obvious fear is displacement. People are fearful of their jobs, of agents doing work that humans used to do.

But I believe that the deeper disruption is structural. Organizational power has always lived in the wait states, the approval gates, the prioritization meetings, the release trains, the "let me loop in so-and-so."

When agents compress cycle time, they don't just remove friction. They remove the leverage points the org chart is built around. The question stops being "who does the work" and becomes "who controls the flow", and when the flow no longer needs controlling, that's an existential question for a lot of roles that never thought of themselves as automatable.

The rate function

Rate of return in finance is pretty steady. In the world of agentic engineering, we get to improve our rate of return:

Productivity = Code Velocity × Feedback Quality × Iteration Frequency

r = V × Q × F

In any single cycle, this is your productivity. But in the agentic era, something structural changes: the output of each cycle improves the inputs of the next. Higher code velocity retires technical debt, which increases code velocity in the next cycle. Better feedback quality improves observability and contracts, which increases feedback quality in the next. Faster iteration frequency reduces friction, which increases iteration frequency in the next.

This is the feedback loop that makes it exponential. The engineering equation isn't the growth curve, it's the rate function inside the exponent. It's what determines how fast you compound. Agents don't just execute the loop, they're also accelerating it.

Why continuous, not discrete

In the automation era, the compounding frequency was gated by human cycle times. Two-week sprints. Monthly releases. Quarterly roadmaps. The machinery between iterations was organizational: standups, approvals, handoffs, prioritization meetings. All wait. All friction.

Agents don't wait for sprint boundaries. They don't wait for the next release train. They don't wait for someone to come back from PTO to approve a pull request. The feedback loop is continuous, feeding back into the input with very little gap. Anyone who's worked with multiple agents at once has felt this. It's hard to stay ahead of them going idle waiting on you.

What happens to the gates

A natural objection: if agents compress cycle time, what happens to governance? To security review? To compliance? Those gates exist for reasons that don't disappear just because the cycle accelerates.

The answer isn't that the gates go away. The answer is that the gates themselves become agentified too. Agentic governance. Agentic InfoSec. Evals as code, running continuously, not as a checkpoint someone schedules on a Tuesday. The wait state disappears but the function doesn't. It gets absorbed into the loop itself.

The approval doesn't happen between cycles. It happens within every cycle, at machine speed, with full traceability. That's not less governance. It's more governance than any human-gated process ever achieved. The ultimate shift-left.

Also, for those who think that introducing more friction and more wait is the answer, the competition, and the threat actors are absolutely not going to wait. In order to keep up you must learn how to harness the advancements or you will find yourself at extreme risk.

Software is the first domino

Everything we've described so far is happening in software engineering first. The compounding, the rate function, the collapsing cycle time. That's not because software is special. It's because software was ready. The raw materials were already in place: version control, structured text, compilers, automated testing, observability, feedback loops.

But look at what "ready" actually means. Artifacts stored in version control. Work products expressed as structured text. Quality validated through automated feedback. Outputs observable and measurable. Every one of those conditions is achievable in every domain. Legal. Finance. Operations. Marketing. Clinical. Regulatory.

As each vertical and domain applies these same patterns, the opportunity for the same level of disruption emerges. Companies that have massive datasets can create their own domain-specific, fine-tuned models. Specialized agents per domain, dialed in with an organization's own special sauce. This is Conway's law as strategic differentiation. Leaning in on the depth of data as operating context. Put these models on top of ecosystems that have version control, structured artifacts and feedback loops. The same compounding equation applies.

Software engineering isn't the story. It's the proof of concept. The pattern is universal.

This is the opportunity. Organizations that start building the raw materials now, encoding their domain knowledge as structured, versionable, evaluatable artifacts, are the ones that will compound. Everyone else will look up in two years and wonder how the gap got so wide, or how their impenetrable moat vaporized overnight.

Buffett's hill was fixed. Yours isn't. But the clock is already running.