The Deep Feed

The traditional metrics of engineering productivity are breaking. At Anthropic, the shift is not merely incremental; engineers are shipping eight times more code per quarter than they were just a few years ago. This isn't about people typing faster. It is about a fundamental change in the unit of work. When the cost of generating a block of logic drops toward zero, the bottleneck shifts from the writing of code to the verification of intent. Fiona Fung, who leads the teams behind Claude Code, is navigating this transition in real-time, managing an organisation that functions more like a high-frequency trading desk than a traditional software shop.

The Death of the Junior Developer Role

As AI agents take over the rote tasks of boilerplate generation and unit testing, the entry-level role is being hollowed out. The 'junior' developer used to spend their first year learning the plumbing of a codebase. Now, the plumbing is handled by Claude. This creates a talent gap: if the bottom rungs of the ladder are removed, how do we train the seniors of tomorrow? The new requirement for engineers is not just technical proficiency, but the ability to act as a high-level architect and a rigorous auditor. You are no longer just a builder; you are a supervisor of digital labourers.

The bottleneck is no longer the writing of code, but the verification of intent.

This shift demands a new kind of management. Fung notes that the context-switching problem remains unsolved. Even with AI, the mental tax of jumping between high-level strategy and low-level debugging is immense. The goal for AI-native teams is to use agents to manage this cognitive load, creating 'routines' where the AI handles the connective tissue of the workday—the status updates, the documentation, the initial triage—leaving the human to focus on the hard problems that models still stumble over.

The risk in this hyper-productive environment is the accumulation of technical debt at light speed. If you can ship 8x more code, you can also break 8x more things. The engineering culture must evolve to include much more aggressive automated testing and guardrails. Without them, the speed of delivery becomes a liability rather than an asset.

Most people use AI as a sophisticated search engine or a better version of Google Docs. They prompt, they receive, they edit. This is 'chat' mode, and it is the lowest form of AI utility. The real power lies in 'loop' mode. A loop is a system where an agent is given a goal, a set of tools, and a way to check its own work. It doesn't stop when it finishes a sentence; it stops when the objective is met. This is the transition from a tool you use to a colleague you delegate to.

The Anatomy of a Goal-Based Loop

The most common mistake in agentic design is providing vague success criteria. If you tell an agent to 'improve the codebase', it will loop forever, burning through your API credits in a futile attempt to reach an undefined perfection. Effective loop engineering requires defining a 'stop condition' that is binary and verifiable. You don't ask an agent to 'make the code better'; you ask it to 'ensure all functions in this directory have 90% test coverage' or 'identify and fix all memory leaks in the networking module'.

A loop is just a prompt that fires itself, but the magic is in the validation.

The next level of complexity is the recursive loop: agents that spawn sub-agents. Imagine a weekly skills loop that identifies gaps in your team's knowledge, then spawns individual agents to research those topics, create tutorials, and verify the information. This isn't just automation; it's the creation of a self-improving organisational layer. The ceiling for this is not your technical ability, but your ability to write a clear job description for a digital worker.

Cost management is the silent killer of agentic workflows. Because agents can iterate hundreds of times in a single run, a poorly designed loop can become a financial black hole. Monitoring the relationship between token spend and actual utility is the new essential metric for the modern developer. You must treat your agentic loops like you treat a cloud budget: with constant scrutiny and clear limits.

When the news broke that Mozilla had shipped a record number of security fixes in a single month, the immediate reaction was to praise the underlying AI model. But the real story isn't the model; it's the harness. Brian Grinstead and his team at Mozilla didn't just point a chatbot at the Firefox codebase. They built a sophisticated, multi-stage pipeline that gave the AI the structure it needed to be effective. The model provided the intelligence, but the harness provided the discipline.

The Verification Engine

The biggest problem with AI-generated code is the false positive. An agent might claim to have found a bug, but in reality, it has just hallucinated a failure or triggered a test-only condition. Mozilla solved this by implementing a two-stage verification process. First, the agent must actually trigger a crash in a controlled fuzzing environment—a physical, undeniable signal of a bug. Second, a separate 'verifier' sub-agent checks the report to ensure it isn't a false alarm. This eliminates the noise that usually makes AI-assisted debugging impossible.

Agents are relentless in a way humans can't be. They will try 20 different approaches to trigger a bug without losing focus.

This relentless nature is a double-edged sword. While an agent won't get tired, it also lacks the 'big picture' intuition of a human engineer. An agent might find a way to patch a vulnerability in one specific location, whereas a human would notice that the same pattern exists in three other places and fix them all at once. The successful workflow, therefore, is not 'AI replaces human', but 'AI does the heavy lifting, and human provides the strategic oversight'.

For any organisation with a large, complex codebase, the lesson is clear: don't wait for a 'perfect' model. The competitive advantage lies in building the custom infrastructure around the model that allows it to interact with your specific tools, tests, and deployment pipelines. The model is the engine, but the harness is the car.

There is a peculiar and unsettling trend in the communication coming from the world's leading AI labs. They release reports that warn of catastrophic, existential risks—scenarios where AI might escape human control or destroy the economy—while simultaneously racing to release more powerful versions of those very same models. Cal Newport calls this 'doom trolling'. It is a form of communication that is both hypocritical and deeply damaging to the collective psyche.

The Moral Calculus of Anxiety

The ethical contradiction is stark. If these companies truly believe that their technology poses an existential threat to humanity, then the only moral response is to stop development immediately and focus all resources on safety. To continue racing while shouting about the dangers is to engage in a form of cynical theatre. It suggests that the warnings are not sincere concerns, but rather a way to frame the technology as an inevitable force of nature that cannot be regulated or slowed.

They are laundering the anxiety of millions to improve the financial fortunes of a vanishingly small number of major stockholders.

By positioning themselves as the 'reluctant stewards' of a dangerous power, these companies avoid the accountability that comes with being normal consumer product companies. Instead of explaining the specific benefits of their tools or justifying their costs, they lean into a narrative of inevitability. This 'doom trolling' serves a dual purpose: it creates a sense of awe and fear that elevates their status, and it creates a defensive crouch in the public, making it harder to demand practical, grounded regulation.

We do not have to accept this narrative. It is possible to build incredibly useful, transformative technology without pretending that every step forward is a step toward the apocalypse. The industry needs to move away from the existential melodrama and back to the hard work of building reliable, beneficial, and transparent products. The era of the 'anxiety bomb' needs to end.

As AI agents become more capable of performing end-to-end tasks, the friction of setting up infrastructure becomes a significant hurdle. If an agent needs to deploy a web application to test a feature, it shouldn't have to go through a ten-step onboarding process involving credit cards and account verification. Cloudflare has addressed this with a new feature: temporary, ephemeral accounts for rapid deployment.

Deploying Without an Identity

Using a simple command—`npx wrangler deploy --temporary`—a developer (or an agent) can now deploy a project to a live URL that exists for exactly 60 minutes. This is a massive win for the 'agentic workflow'. It allows an AI to spin up a sandbox, test a hypothesis, verify a redirect, or demonstrate a capability, and then vanish without leaving a footprint or a bill. It turns infrastructure into something as transient as a text message.

While the marketing focuses on 'AI agents', the utility for human developers is equally high. It provides a way to share a quick, live demo of a local project without the overhead of permanent hosting. It is a move toward 'just-in-time' infrastructure that matches the speed of modern, iterative development.