Sally Ann O'Malley

The new application layer belongs to agents We have reached a point where software engineering is facing its most significant disruption since the invention of the compiler. Malte Ubl, CTO of Vercel, argues that AI agents are not just a tool but a fundamental new kind of software. In the past, many automation ideas were discarded because they weren't economically viable using traditional coding methods. Writing a complex web of if-statements and hardcoded business logic was too expensive for niche tasks. Now, agents make that part of the software landscape viable. We are essentially speedrunning an experiment in economic elasticity: the cheaper it is to make software, the more software we will create. This shift moves the industry from a world of "builders vs. users" to a world where agents inhabit both roles. At Vercel, the team discovered that over 60% of their page views now come from agents, not humans. This has immediate implications for how we design interfaces. Graphical user interfaces (GUIs) are becoming a secondary concern, while command-line interfaces (CLIs) and APIs are the primary way software interacts with the world. When an agent is the user, it doesn't need a pretty dashboard; it needs a structured protocol. This paradigm shift forces us to rethink the very nature of software deployment and infrastructure, moving away from manual configurations toward automated, agent-driven environments. DeepMind pushes AI beyond the limits of language While language models dominate the conversation, Google DeepMind is expanding the boundaries of what intelligence can do in the physical and digital worlds. Raia Hadsell highlights that the future of AI isn't just about text—it's about understanding complex physical systems like the weather and creating immersive world models. GraphCast, a spherical graph neural network, can predict the state of the atmosphere 15 days out with higher accuracy than traditional physics-based models. In critical situations like Hurricane Lee, AI models provided accurate landfall predictions three days earlier than the industry's gold standard. Beyond weather, DeepMind is pioneering "world models" with Project Genie 3. This isn't just video generation; it is a playable, interactive environment created from a single image or text prompt. These models understand the "physics" of a scene—they know that if you walk into a puddle, the water should ripple. They maintain consistent memory, allowing a user to walk a mile in one direction and return to find the same structures intact. This represents a leap toward Artificial General Intelligence (AGI) that can navigate and interact with the world as humans do, opening new frontiers for education, simulation, and entertainment. Implementation is no longer a scarce resource The scarcity in software engineering has shifted. Ryan Lopopolo from OpenAI states a provocative truth: code is now free. In late 2025, with the release of advanced models like GPT-5.2, implementation ceased to be the bottleneck. An engineer no longer just manages their own output but acts as a staff engineer orchestrating dozens or thousands of agents simultaneously. The primary constraints are now GPU capacity and token budgets, not human typing speed. This abundance of code means that technical debt and refactoring are no longer terrifying burdens. If code is free to produce, it is also free to delete and rewrite from scratch. In this environment, the engineer's role moves toward systems thinking and delegation. We are entering the era of the "dark factory" for code, where vast repositories can be refactored overnight by swarms of agents. Vincent Koc describes running up to 15 parallel Cursor sessions to execute massive architectural changes that would have taken human teams months to complete. However, this velocity requires new guardrails. Instead of reviewing every line of code, engineers must build "harnesses"—automated systems of lints, tests, and security agents that enforce non-functional requirements. You don't review the code; you review the process that generated it. OpenClaw and the rise of personal AI infrastructure OpenClaw, created by Peter Steinberger, has become the fastest-growing project in GitHub history, signifying a massive demand for local, controllable AI. Unlike closed systems that require users to upload their sensitive data to a corporate cloud, OpenClaw allows individuals to run a powerful agent on their own infrastructure. This "hacker's way" of building AI provides a mechanism to bypass the silos created by big tech. If an agent can inhabit a local environment, it can access emails, files, and calendars without permission from a central authority. However, running an agent with the "keys to your life" introduces severe security challenges. Steinberger notes that OpenClaw is often targeted by security researchers because its power is inherently dangerous. Any system with access to private data and the ability to communicate can be exploited via prompt injection. The industry is responding with innovative deployment strategies. Sally Ann O'Malley of Red Hat advocates for running agents strictly in containers or Kubernetes pods to isolate secrets and ensure state recovery. By mounting specific directories and using secret references, developers can provide agents with the tools they need while maintaining a "blast radius" that protects the host system. Software fundamentals are the ultimate moat With agents churning out massive amounts of code, many fear that traditional engineering skills are becoming obsolete. Matt Pocock argues the exact opposite: software fundamentals matter more than ever. When you use AI to turn specs into code without understanding the underlying architecture, you often end up with "AI slop"—code that is brittle, shallow, and impossible to maintain. AI tends toward "software entropy," where every new change makes the system slightly more complex and disordered. To counter this, engineers must double down on Domain-Driven Design (DDD) and Test-Driven Development (TDD). By establishing a "ubiquitous language"—a shared terminology between the human and the AI—you ensure that the agent understands the domain it is working in. Furthermore, designing "deep modules" with simple interfaces allows an engineer to delegate implementation to the AI while keeping the overall system design clean. You treat the AI as a highly capable sergeant on the ground, but you remain the architect. If the codebase is well-structured, the AI performs brilliantly. If the codebase is a mess, the AI will only accelerate its collapse. Moving from tool calling to code execution The current standard for AI interaction, JSON-based tool calling, is reaching its limit. Sunil Pai from Cloudflare explains that stuffing hundreds of tool definitions into a context window is inefficient and slow. For large API surfaces—like Cloudflare's 2,600 endpoints—traditional Model Context Protocol (MCP) setups can consume millions of tokens. The solution is "Code Mode," where the model generates JavaScript that executes directly within a secure V8 isolate. This shift allows agents to inhabit the state machine of an application rather than just calling its functions. For example, an agent can inspect a canvas of strokes, recognize a game of tic-tac-toe, and execute a code snippet to draw a winning move without ever having been explicitly programmed for that game. This leads to the concept of "Generative UI," where software is no longer a static product but a dynamic environment that reconstructs itself for every user. The future of software is not a collection of buttons and forms; it is a safe sandbox where code does the talking, enabling a level of personalization and efficiency that was previously unimaginable.