Every Engineer Is Now a Manager — Whether You Signed Up For It or Not

The Wall I Hit in Amman

Three months ago, I watched a Laravel queue worker I'd written get replaced by an AI agent that wrote its own retry logic.

Not because the agent was better. Because I spent six hours in a meeting arguing whether our Next.js admin panel should show agent confidence scores or raw token probabilities. While the agent kept shipping.

That's when it hit me: I'm not fighting AI for my job. I'm fighting to stay technical while becoming a manager I never asked to be.

The Friction of "Vibe Coding"

You've seen the demos. Cursor, Claude Code, Lovable — type a prompt, get a deployable branch. The MENA startup ecosystem is drowning in founders who think they've eliminated engineering.

They're wrong. But so are we.

The friction didn't disappear. It moved up the stack. Now I spend my mornings at Alrajhi Bank reviewing agent-generated React Native modules not for syntax errors — those are gone — but for:

• Regulatory compliance: Does this KYC flow satisfy SAMA's sandbox requirements?
• Audit trails: Can we prove why the agent chose this biometric vendor?
• Failure modes: When the LLM hallucinates a Saudi IBAN format, who's on-call?

The code is cheap. The context is expensive.

From Artisan to Air Traffic Controller

Twenty years ago, I measured productivity in commits. Now I measure it in decision velocity.

My team runs 12 autonomous agents across our banking infrastructure. Each agent has:

• A budget ceiling (inference tokens + API calls)
• A risk profile (can it touch prod? customer data? core banking APIs?)
• An escalation ladder (when does it wake a human?)

Sound familiar? That's management. I'm running a distributed team where half the "engineers" are stochastic and need constant performance reviews.

The Laravel applications I maintain now serve as governance layers — not business logic executors. My Next.js frontends are observability dashboards for agent behavior. The actual "work" happens in headless loops I can't step through with a debugger.

The MENA Reality Check

Jordan's tech scene taught me something Silicon Valley misses: infrastructure constraints breed better managers.

When your GPU cluster lives in Frankfurt because AWS Riyadh doesn't have the capacity, you learn to optimize for latency of decision-making, not lines of code. When your mobile banking app needs to function on 3-year-old Android devices with intermittent connectivity, you can't afford agent experiments that "mostly work."

I see Egyptian fintechs, Emirati neobanks, Saudi payment rails — all converging on the same pattern. The engineers who thrive aren't the ones prompting hardest. They're the ones who architect the guardrails.

What "Managing" Actually Means Now

Let me be specific about what changed in my daily work:

Budget ownership: Every agent invocation is a line item. I negotiate with finance whether our fraud detection agent gets GPT-4 or Claude 3.5 Sonnet based on latency/cost trade-offs. That's resource allocation.

Stakeholder translation: Business wants "AI personalization." I translate that into: agent prompt templates, A/B test frameworks, fallback rules when personalization violates SAMA guidelines. That's requirements management.

Team health: My human engineers are burning out faster because the cognitive load shifted. They're not debugging code — they're debugging intent alignment between agents. That's people management.

Risk posture: When an agent suggests a database migration based on schema inference, I'm the one who says no. Not because it's wrong. Because I can't prove it's right to an auditor. That's governance.

The Stack Becomes the Org Chart

Here's what hurts: the tools I love are becoming management interfaces.

Laravel used to be about elegant Eloquent relationships. Now it's about authorization policies for agent actions — can this service account trigger a wire transfer? Should it?

Next.js used to be about SSR performance. Now it's about streaming agent responses — how do we render confidence intervals in real-time without freezing the UI?

React Native used to be about bridge modules and native performance. Now it's about offline-first agent synchronization — how do we queue agent tasks when the user loses signal in rural Jordan?

The architecture diagrams I draw look less like layered cakes and more like organizational charts — with humans, agents, and legacy systems as nodes, and trust boundaries as the edges.

The Headroom Problem

There's a ceiling on how much complexity one human can orchestrate. I used to think that ceiling was cognitive — how much code can I understand?

Now I know it's attentional. How many agent contexts can I hold simultaneously while remaining accountable for outcomes?

At Alrajhi, we're experimenting with meta-agents — systems that manage other agents. This should solve the scaling problem. Instead, it created a recursive management burden: who manages the meta-agent? Who reviews its reviews?

The answer, so far, is me. And every engineer I know in similar roles.

What We Lose, What We Keep

I miss the gravity of production deploys. The certainty that I wrote the logic, I understood the edge cases, I could explain the failure mode to a regulator at 3 AM.

Now I ship systems I can only characterize statistically. "This agent performs 94% accuracy on our test suite" — that's not engineering. That's quality assurance for a black box.

But here's what I gained: leverage at a different scale. One engineer with good agent orchestration can cover what used to require a squad. In emerging markets where technical talent is scarce and expensive, that's not optional. That's survival.

The Contrarian Take

Everyone says "learn to prompt better." I say: learn to manage better.

Prompt engineering is a local maximum. The engineers who will own the next decade are building:

• Evaluation frameworks (how do you know your agent improved?)
• Fallback architectures (what happens when the LLM provider changes their model?)
• Audit infrastructure (how do you reconstruct a decision for compliance?)

These aren't coding skills. They're organizational design skills applied to software.

The Jordanian Perspective

In Amman, we have a phrase: "El-maktaba elly ma feeha ketaab, ma feeha 3alam" — the library without books has no flags. Meaning: you need substance to signal status.

The global AI discourse is obsessed with flags — demos, benchmarks, hype. In MENA fintech, we're obsessed with substance — provable correctness, regulatory defensibility, operational resilience.

That makes us conservative. That also makes us better prepared for the actual future, where AI isn't a magic wand but a risk vector requiring constant supervision.

Your New Job Description

If you're still reading, you're probably wondering: what should I actually do?

Stop optimizing for code output. Start optimizing for system comprehension.

• Can you explain why an agent made a decision to a non-technical stakeholder?
• Can you design a circuit breaker that fails safely when agents disagree?
• Can you price the cost of an AI feature in tokens, latency, and cognitive load?

These are management questions. They're also engineering questions now.

The Tsunami Isn't Coming. It's Here.

I didn't choose to become a manager. The architecture of modern systems — especially in regulated industries like banking — made it inevitable.

The developers who resist this shift will find themselves squeezed between "vibe coders" who ship faster and cheaper, and "AI engineers" who actually understand the systems underneath. There's no middle ground anymore.

Your choice isn't whether to manage. It's whether to manage well — with explicit frameworks, measurable outcomes, and honest accounting of where human judgment adds value.

Or to manage poorly — by pretending you're still just "coding" while the complexity tsunami washes over you.

The Real Question

Twenty years in, I've learned that disruption doesn't replace expertise. It relocates it.

The expertise that mattered in 2005 was algorithmic. In 2015, it was architectural. In 2025, it's orchestrational — the ability to compose reliable systems from unreliable components, human and artificial.

So here's my provocation: When was the last time you wrote code that no agent could have generated — not because of complexity, but because of accountability?

If you can't answer that, you're already a manager. The only question is whether you're getting paid like one.