The Agentic Promotion
AI coding tools force an unacknowledged promotion, shifting developers from individual contributors to engineering managers of synthetic agents.
By Elena Voss
Sparked by Making · discussion
Recently, Brian "Beej" Jorgensen Hall published a short reflection on AI and the concept of making, capturing a creeping malaise among developers who are realizing they fundamentally miss the tactile act of writing code. It immediately triggered an existential Hacker News discussion where hundreds of developers reported a profound, unexpected loss of joy. Reading through the thread, the specific mechanics of their exhaustion were glaring. Engineers are finding themselves abruptly transitioned into full-time quality assurance for an entity that types at blinding speeds but lacks basic judgment. They are tired of managing unreliable output and policing generated syntax instead of architecting the logic themselves.
The prevailing industry narrative insists that these tools are straightforward amplifiers that turn average developers into legendary 10x individual contributors. Evaluating that macroeconomic fad against the widespread alienation in that thread reveals a severe disconnect. The promised leverage is supposedly absolute, yet the lived reality of integrating these tools feels remarkably like an administrative slog. Tracing the root of this exhaustion requires examining the underlying constraints of the delivery machine. This developer alienation is the predictable organizational physics of an unacknowledged promotion from individual contributor to engineering manager.
We can model this psychological shift directly through queueing theory. In any software delivery system, output is constrained by a strict formula: Velocity = min(Execution Time, Verification Judgment). Historically, typing code into an editor—execution time—was the primary bottleneck, giving engineers ample space to build mental models and apply judgment concurrently. The physical speed of typing roughly matched the cognitive speed of thinking. By driving execution time to near-zero, AI tools completely invert the system’s constraints, causing the judgment node to back up catastrophically. The exhaustion developers report is simply a symptom of this queued bottleneck. The role of the software engineer has structurally shifted from creation to verification.
If you are now effectively an engineering manager of synthetic agents, you must apply standard management heuristics to survive the transition. Treating a Large Language Model like an omniscient senior engineer who never needs oversight will generate endless cycles of technical debt. We survive unmanageable complexity by forcing it into deterministic, tightly constrained boundaries. For engineers teetering on the brink of this shift, I recommend deploying a specific taxonomy of constraints: The Agentic Promotion playbook.
1. Enforce strict Work-In-Progress (WIP) limits. Delegating a dozen concurrent exploratory tasks to an LLM guarantees cognitive fatigue for the human reviewer. When the cost of generating a pull request drops to nearly zero, the natural temptation is to spin up multiple agents to tackle parallel technical vectors. This invariably leads to massive context collapse for the sole human left to review the deluge. Standard management theory applies perfectly here: WIP limits improve throughput by constraining context switching. Treat your agent pool like a junior team that requires intense, synchronous pairing. Limit agents to one or two active tasks at most (an artificial ceiling, admittedly, but a highly necessary one), forcing the system to complete the verification cycle before initiating a new chaotic tendril of execution.
2. Formalize inspected trust. Just as an engineering leader cannot blindly approve a sprawling, unverified pull request from an enthusiastic new hire, you cannot accept uninspected AI output into a production environment. Relying on generic "prompt engineering" generates a false sense of architectural consensus while silently accumulating exception debt in the dark corners of your codebase. Replace conversational prompt tweaks with rigid, formal inspection mechanisms: mandatory test-driven development boundaries, automated linters, and architectural fitness functions. Uninspected synthetic code is simply a liability waiting for a trigger. Genuine evaluation is a structural requirement for leverage: it means defining the exact parameters of success upfront rather than crossing your fingers and hoping the model stumbles into local maxima.
3. Update baseline operational properties. Managing non-human entities requires fundamentally shifting your default environmental configurations. Human developers write code that inherently attaches copyright; machine output legally lacks the capability for copyright ownership. This alters the baseline licensing constraints of the artifacts you generate. If you are scaffolding entirely new modules using agents, you must transition your default open-source expectations—perhaps moving from MIT to the Unlicense to accurately reflect the reality of uncopyrightable works. Your operational environment must mirror the legal and structural realities of the entities doing the typing. Assuming old organizational properties safely apply to a brand new system architecture is how you end up with legally toxic lost technology later.
4. Accept the sacrifice of low-level context. The most painful phase of becoming a first-time engineering manager is grieving the loss of deep, line-by-line codebase understanding. The shift toward agentic development demands the exact same psychological sacrifice. You must learn to evaluate systems by their architectural boundaries, integration points, and emergent properties, rather than attempting to hold the entire localized implementation in your head. Navigating the tension between granular control and macro-level velocity is notoriously difficult, but sacrificing the former for compounding leverage is the explicit cost of operating at a higher level of abstraction. This mirrors traditional hiring loops: we evaluate senior staff not on their pure typing output, but on their ability to accurately size and delegate complexity. A mid-level individual contributor is expected to miss parts of the broader infrastructure perspective, but a manager—even a manager of agents—cannot afford to miss the system architecture because they were too busy parsing syntax.
Letting go of the granular joy of writing every single line is a deeply uncomfortable career transition. Many engineers will spend the next few years attempting to force AI tools back into the familiar shape of a standard text editor, effectively mourning a lost era of localized craftsmanship. Mourning will not rewrite the mathematical constraints of the new machine. Executing a flawed system of delegation is always better than becoming the organizational bottleneck out of stubborn nostalgia. As you invest in your technical leverage over the span of a multi-decade career, you have to pace yourself for these massive, tectonic shifts in abstraction. The specific syntactical tools will inevitably change, the necessary level of abstraction will continually rise, but the fundamental bottleneck of human judgment remains the only constraint that cannot be automated away.