The moat was never the code

Coding was the bottleneck. What's left for a mid-career engineer once AI removes it: evals, agent architecture, context, governance and knowing the domain.

Published: ·5 min read·First on Substack

I barely write code anymore. I'm a senior developer at HSBC, I optimise legacy systems, orchestrate AI agents that talk to each other and help relationship managers do their jobs faster, and most of the code I ship is AI-generated. My job has quietly turned into prompting my way through problems. For a few months that gave me a low-grade crisis: if the model writes the code, what exactly am I adding?

I don't think I'm the only mid-career engineer sitting with that question, and the advice going around doesn't touch it. Learn Python. Learn machine learning (drill down on the basics). Stay curious. None of that tells you what a human engineer brings once an LLM writes better code than most principal engineers, which looks a few years away at most.

Here's where I've landed. Coding was never the moat. It was the bottleneck. The value was always judgment, domain knowledge and systems thinking, but you couldn't see them because they came wrapped inside the act of typing code. AI has removed the bottleneck, so now everyone has to compete on the stuff behind it, which was always more important and is much harder to fake.

Removing a bottleneck has a side effect, though. It shows you the next constraint, and mine turned out to be my own sense of what to learn. When I brainstormed it, the list looked like this: linear algebra, differential equations, machine learning concepts, Go for concurrency, advanced SQL optimisation, blockchain, UI/UX design and quantum computing. I showed it to a few friends to see what they thought I should pick next. It felt like a serious list. It was almost entirely wrong.

A classic response to career anxiety: casting wide and mistaking breadth for progress.

Linear algebra and differential equations matter if you're building models from scratch. I'm not. I'm building systems on top of models, and knowing that attention is matrix multiplication gives me almost nothing I can use on a Tuesday. Go is great for high-performance concurrent services, but I already have Python and some Scala, and a third language before I've consolidated anything is just spreading thin. Blockchain has been the next big thing for a decade and has very few production uses outside crypto. Advanced SQL optimisation is a real skill for a DBA-shaped role, which isn't where I'm going. Quantum computing is fascinating and irrelevant to my career for at least ten years. The list was career anxiety written down: cast wide, grab whatever sounds impressive or fundamental, and mistake breadth for progress.

What matters, I think, is much less glamorous.

The first is evaluation and observability. In a regulated bank, "it seems to work" is not a position you can hold. If an agent is helping 15,000 relationship managers make decisions about clients across a hundred geographies, you need a systematic way to know whether it's getting better or worse, what each query costs, where it fails and how you catch a regression before it becomes an incident. I already use Langfuse for tracing, but having used a tool and owning the discipline are very different things. The person who walks into a senior meeting with a quality trend, an LLM-as-judge scoring system and a prompt regression suite that runs on every change is the most credible voice in the room on AI. Almost nobody is doing this properly yet.

The second is agent architecture. I work with Google's ADK, which abstracts a lot away. That's useful right up until something fails in production in a way the framework never anticipated, or you need to defend single-agent versus multi-agent to a sceptical principal engineer. Knowing the underlying patterns (orchestrator and worker, parallel fan-out, evaluator loops, human checkpoints) and, more importantly, how each one fails means you aren't locked to one framework and you aren't guessing. My distributed systems background helps more than I expected here, because an LLM tool call is just a non-deterministic network call. Treat it like one: timeouts, retries, dead-letter queues, fallbacks. The patterns transfer almost unchanged.

The third is context engineering. It sounds like a buzzword, but it's the most concrete skill on the list. The model's raw ability is fixed; what you put in front of it decides almost everything else. How you structure a system prompt, how you shape tool schemas so the model calls them reliably, how you get the right information into context at the right moment, what you do with a conversation that's run long. Those decisions are the difference between an agent that works in production and one that works in a demo.

The fourth, and the most underrated, is AI security and governance, especially in financial services. Prompt injection, where something malicious inside a tool response tells your agent to do what it shouldn't. Sandboxing, and deciding which tools need a human to approve them and which actions can't be undone. Audit logs that record why an agent did something as well as what it did, so that when a regulator asks about a decision it made six months ago, you have an answer. None of this is hypothetical. These are regulatory requirements waiting to arrive, and the person who has already thought them through is in a very different position from the person who hasn't.

All four rest on judgment, and I've stopped believing courses are the main way to get it. Designing Data-Intensive Applications is worth reading, not to memorise but to steal mental models from (the chapters on replication trade-offs and on consistency versus availability, mainly). They give you words for decisions you're already making on instinct. But judgment itself comes from being put in decision-making seats faster than your years of experience would naturally allow.

One more thing doesn't fit a skill category. I've worked in financial services for a few years and I'm still scratching the surface of how correspondent banking actually works, what compliance officers genuinely worry about, or what "know your customer" means once you have to implement it. That domain depth is something a model can't hand you, and it makes every architectural decision sharper because you know the constraints you're working inside. An agent that works technically but creates a compliance problem isn't a win. The person who understands both halves of that sentence is the one who's hard to replace.

AI gets better at writing code every month. I've stopped counting that as bad news.