# Engineering principles for an agentic future Joseph Denne · November 2026 · https://josephdenne.com/articles/engineering-principles-for-an-agentic-future.html Programming as a manual craft is ending. In fact I'd argue it's over. But engineering is not. We're adopting new operating principles at XE for building with agents. They're written for our engineers, but I don't think they're specific to us. --- ## The shift is already here Writing code by hand as the primary job is over. It's not coming back. Models and agent tooling now produce production-grade work at a pace and volume that makes the old model obsolete. This isn't a forecast. It's what's on the screen. For us it's an advantage. XE is the agent-native network: identity, discovery, payment, compute and messaging built for machines rather than for the people behind them, with every account on its own chain. The same forces remaking software should remake how we build and operate the network itself. Our competitors, the centralised clouds and the chains built for human wallets, are pouring capital into AI-native tooling and agent-ready infrastructure, so falling behind isn't a marketing risk, it's existential. ## Why it might not feel like the baseline Three reasons. **Role and mindset.** Your job as a developer is no longer to write the code. It's to make agents write better code, faster, with less supervision. Treat models and agents as direct reports: guide them, correct them, and above all expand what they can do unsupervised. When an agent fails, fix the immediate problem and then make the next attempt better for everyone. Better repository context; shared skills and prompts; automated investigation of repeated failures; tighter feedback loops into the platform. Push the boundary of autonomous work outward, and step in only where judgement (taste is at the prompt!), system understanding or accountability still need a person. **We're still mostly in the first phase of this shift.** Using agents to speed up individual coding tasks inside existing workflows is useful, and incomplete. Removing the writing-code bottleneck doesn't remove the constraint; it moves it, to CI speed and capacity; to design and specification; to approvals, observability, code review, and deployment across a distributed network. Later phases will mean looking at the whole development and operations lifecycle, eliminating bottlenecks ruthlessly, and redesigning processes rather than accelerating the old ones. Most human code review will eventually disappear. Agent-native CI, deployment and monitoring will be the default. At XE our network already treats agents as the customer, with identity, discovery and payment as primitives. Our internal tooling meets the same standard. And we're in the process of making agents operators of the organisation as well. **So this is about coordination, not just individual effort.** Any engineer can get faster with agents on their own work. Rethinking CI, observability, deployment pipelines or shared context for a whole team requires deliberate investment. We don't always know where the real bottlenecks are, because we haven't instrumented them yet. And that's okay, and solvable. ## What doesn't change Expertise isn't obsolete. Engineers still bring system understanding, judgement about distributed systems, failure modes, security and accountability that models currently lack. A human plus an agent is stronger than either alone. So good engineering still matters. Maintainable architecture, clear interfaces and appropriate testing remain important. What changes is the cost curve: when writing and maintaining tests or documentation becomes cheap, the old trade-offs should be revisited, not inherited. Fundamentally our mission stays the same: open, verifiable infrastructure for the machine economy, not controlled by a handful of hyperscalers. ## What it means for every engineer You own both the outcome and the method. Continuously optimise for more automation and more autonomous agent work, then share the improvements: skills, prompts, context files, tooling. Build as if agents are the primary users of both the product and the internal tools. Prefer interfaces an agent can discover, understand and operate without babysitting. If it needs a human to hold its hand, it isn't finished. ## Bottom line Programming as a manual craft is ending. Engineering is not. Your job as a builder and orchestrator of agents gives you more leverage than the old model ever did. --- © Joseph Denne. Quote with attribution and a link to the canonical URL.