Chloe Maraina is a veteran of the software industry who has witnessed the radical transformation of deployment from a reckless manual task to a highly regulated engineering discipline. With a deep background in Business Intelligence and a vision for the future of data integration, she offers a unique perspective on the current explosion of agentic coding. Today, she shares her insights into the “tokenmaxxing” trend, the evolution of software governance, and why practitioners must take the lead in establishing the rules for AI-driven development before they are imposed by outside forces.
The conversation explores the historical parallels between the early, chaotic days of application deployment and the modern rapid adoption of AI-driven coding agents. Key themes include the transition from simple executable file transfers to the formalized standards of the Sarbanes-Oxley era, the hidden costs and questionable ROI of the current “tokenmaxxing” craze, and the critical need for an organic governance process. We also examine the psychological shift of developers moving from furtive AI use to full-scale reliance and the inherent dangers of top-down regulations that cannot keep pace with technological acceleration.
Looking back at the earlier days of software development, how has the process of moving code into production evolved from a simple file transfer into the complex, regulated systems we use today?
I distinctly remember the era when deploying an application was as deceptively simple as copying a single *.exe file from a developer’s machine directly into the production environment. While that sounds like a dream in terms of speed, it was actually a process fraught with peril because applications were becoming far too complex for such a reckless approach. Over the years, we learned that proper deployment requires a rigorous structure for two main reasons: ensuring every single deployment succeeds without breaking the environment and thoroughly testing how all moving parts interact. These hard-won lessons eventually became formalized, and in some cases, laws like the Sarbanes-Oxley Act required IT departments to document these processes as a form of essential governance. Today, that level of oversight is exactly what separates a professional, high-functioning organization from one that is essentially flying blind.
We are currently seeing a massive shift toward agentic coding, but how did we move so quickly from developers using AI in secret to the industry-wide embrace of these tools?
The transition happened with a speed that was almost dizzying, moving from cautious experimentation to full-scale adoption in a matter of weeks. Initially, many of us were using tools like Claude Code almost furtively, letting the AI find and fix bugs while we quietly checked in the solutions without necessarily broadcasting how they were generated. There was a brief period of hesitation where we felt a bit of guilt for taking the credit, but within just one week, it became clear that the AI was more than up to the task. Once that realization hit, the secrecy vanished and was replaced by an environment where AI usage was not just accepted but actively encouraged. Within a single month, the industry went from zero to “tokenmaxxing,” and suddenly everyone was racing to generate as much code as possible using these agents.
With the rise of “tokenmaxxing,” there seems to be a lot of activity and spending, but what are the underlying risks when it comes to the actual value being generated?
Right now, the situation feels a bit out of control because we are seeing non-trivial amounts of money being poured into AI-generated code without a clear understanding of the return on investment. While there is a massive volume of code being produced, I am not at all sure if anyone can definitively say that this spending is returning the value the industry actually needs. It is a chaotic phase where there is very little control over which tools are being used, how much they cost, or what the end goal truly is for all that expenditure. This lack of oversight reminds me of the “copying the *.exe” phase of deployment, where the immediate ease of the action blinds people to the long-term instability it might be creating. If we don’t find a way to measure and control this output soon, we risk a significant backlash when the bill for all those tokens finally comes due.
Why is it so important for governance in agentic coding to arise organically from practitioners rather than being imposed from the top down?
The governance we have for deployment today is successful precisely because it arose organically from the lessons learned by people who were actually building and deploying software. When practitioners lead the way, the resulting procedures are grounded in reality and address the specific technical challenges we face every day. If we allow a top-down governance process to be forced upon us, it will likely be too rigid or too slow to keep up with a technology that is moving as fast as AI. As Uri Haramati, the co-founder of Torii, often points out, the person closest to the tool is the one who truly understands why it is being used and how it should be governed. We need to take a deep breath and slow down just enough to ensure that we are the ones defining the rules, rather than having them dictated by people who aren’t in the trenches.
As someone who has seen these cycles of innovation and regulation before, what role do you think developers must play in navigating this “reckless” phase of AI adoption?
Developers are the ones with the most skin in the game, and because of that, we must be the ones to provide the roadmap for how these tools are integrated into our workflows. We are currently in a phase that is comically reckless, similar to those early days of manual file copying, and we cannot afford to wait for someone else to fix it for us. We need to actively look at how we are using these agents and establish our own internal standards for testing, auditing, and validating AI-generated code. If we don’t take the lead in providing this governance now, we will inevitably have a heavy-handed, regulated process forced upon us by stakeholders who don’t understand the nuances of the tech. It is our responsibility to figure out the right way to do agentic coding while we still have the freedom to shape its future.
What is your forecast for the future of agentic coding over the next few years?
I believe we are headed for a period of significant consolidation where the “wild west” of tokenmaxxing will be replaced by highly specialized, governed AI workflows. We will likely see a shift away from just generating volume and toward high-precision agents that are integrated into existing CI/CD pipelines with the same level of rigor we apply to manual code. However, this will only happen if we can successfully bridge the gap between the speed of AI development and the necessity of corporate accountability. If we succeed, agentic coding will become the standard foundation of all software engineering; if we fail to self-govern, we may face a “winter” of heavy regulation that stifles the very productivity gains we are currently chasing.
