I've watched the same pattern for 20 years. Developer learns React. Developer learns Next.js. Developer learns the next abstraction layer. Salary plateaus anyway.

The ceiling isn't technical. It's architectural. It's the gap between "I write code" and "I own outcomes."

At Alrajhi, I see this daily. Two engineers, same stack (Laravel, Next.js, React Native), same years of experience. One makes $60K. The other makes $78K-plus. The difference? Seven specific capabilities that have nothing to do with syntax.

Skill 1: Production Incident Ownership

Most developers run from production fires. The $18K premium goes to the ones who run toward them.

I'm not talking about on-call rotation theater. I mean true ownership: the 3AM alert, the corrupted transaction state, the AI agent that's hallucinating payment authorizations. You stay until root cause. You write the post-mortem that actually changes system design.

In our banking infra, we had a Laravel queue processor that would silently fail on specific Arabic character encodings. Three teams knew about it. One engineer — now our platform lead — spent a weekend tracing through Horizon, MySQL binary logs, and downstream React Native sync states. Fixed it permanently.

That's worth $18K. The skill isn't debugging. It's consequence absorption.

Skill 2: Cross-System Mental Models

Framework expertise has a half-life. Laravel 11 looks different from Laravel 5. But the physics of distributed systems? That compounds.

The engineers who break salary ceilings can hold three system layers simultaneously:

• The Next.js frontend's hydration boundary
• The Laravel API's queue concurrency and connection pool
• The React Native bridge's async storage and offline conflict resolution

And they see how changes in one create tsunamis in others.

In MENA fintech, this matters more than Silicon Valley. Our users have intermittent connectivity. Our regulators demand audit trails that cross mobile, web, and core banking. The engineer who can trace a transaction from biometric auth in Riyadh to ledger commit in Jordan — that's architectural thinking. That's premium pricing.

Skill 3: AI Agent Orchestration (Not Just Prompting)

Everyone's playing with ChatGPT wrappers. Few are building agent systems that survive enterprise reality.

Our AI agents at Alrajhi handle KYC document verification, fraud scoring, and customer service escalation. The $18K difference isn't who writes better prompts. It's who understands:

• Failure modes: What happens when the LLM hallucifies a regulatory threshold?
• Observability: How do you trace an agent decision through to audit requirements?
• Human-in-the-loop design: Where does friction actually help vs. hurt?

I built a Laravel-based agent orchestrator that routes between GPT-4, Claude, and local models based on latency, cost, and confidence thresholds. The hard part wasn't the API calls. It was the circuit breakers, the fallback chains, the rollback mechanisms.

That's infrastructure thinking. That's the premium.

Skill 4: Regulatory Translation

In emerging markets, compliance isn't overhead. It's competitive moat.

Saudi SAMA regulations. Jordanian CBJ requirements. UAE DFSA frameworks. The engineer who can read a 200-page circular and translate it into system constraints — database schemas, API rate limits, retention policies — becomes irreplaceable.

I once spent three weeks mapping SAMA's "customer due diligence" requirements to our Laravel models. Sounds boring. But that mapping became the foundation for our AI agent training data, our React Native offline sync logic, and our Next.js admin dashboards.

Regulatory fluency is domain expertise with teeth.

Skill 5: Migration Physics

Greenfield projects are rare. Brownfield resurrection is the real work.

The $18K skill is migration architecture: moving live systems without breaking the money pipe.

We recently migrated a core Laravel 8 monolith to a modular Laravel 11 structure with event sourcing. The technical patterns are documented. The hard part was:

• Hot migration: Dual-write periods, verification scripts, rollback windows
• Stakeholder gravity: Convincing risk committees that "zero downtime" is achievable
• Team momentum: Keeping 40 engineers productive while the ground shifts

Migration physics is about headroom — the space you create for others to work while you rebuild the floor.

Skill 6: Cost-to-Complexity Arbitrage

Cloud bills are the new performance optimization. But most engineers optimize locally.

The ceiling-breaker sees cost architecture: which systems need GPUs, which can run on spot instances, where caching actually pays off vs. where it's premature optimization.

I cut our AI inference costs 40% by moving from synchronous OpenAI calls to async Laravel queues with local model fallbacks. The React Native app got faster (less waiting on network). The Next.js dashboard got richer (more budget for complex queries). The agents got more reliable (rate limit protection).

Cost optimization is system design with economic constraints.

Skill 7: The Documentation of Decisions

Not code comments. Not wiki pages. Decision records that survive turnover.

Every $18K premium engineer I know maintains ADRs (Architecture Decision Records) that capture:

• What we considered
• What we rejected and why
• The consequences we're accepting
• The conditions that would make us reconsider

In Jordan's tight talent market, this is survival infrastructure. When your senior Laravel engineer moves to Dubai, the decision context doesn't leave with them.

I have 200+ ADRs in our repo. Some from 2019. I still reference them when new engineers ask "why not GraphQL?" or "why not serverless?" The answers are contextual, not absolute. Documented context preserves institutional velocity.

The MENA Multiplier

Here's what the generic "7 skills" articles miss: geography changes the value function.

In MENA fintech, these skills compound:

• Regulatory translation × emerging market complexity = rare expertise
• Migration physics × legacy core banking = high-stakes differentiation
• AI agent orchestration × Arabic NLP gaps = genuine innovation opportunity

We're not implementing Silicon Valley playbooks. We're building on sand that shifts — regulatory, infrastructural, cultural.

The $18K premium isn't about being 20% better at React. It's about being the person who can navigate uncertainty while shipping systems that move money.

The Real Ceiling

After 20 years, here's my contrarian take: salary ceilings are consent structures.

Most developers accept the frame they're given. "Senior" means 5 years. "Staff" means 10 years. The ceiling is imaginary until someone breaks it.

The seven skills above aren't about climbing a ladder. They're about making the ladder irrelevant. When you can own production, translate regulation, orchestrate AI, and document decisions that outlast your tenure, you stop competing on years-of-experience.

You compete on risk absorption.

And banks — especially in MENA, especially in fintech — will pay for risk absorption. Because the alternative is systems that fail in ways that make headlines.

What I'm Building Now

At Alrajhi, we're pushing these skills into our hiring and promotion frameworks. Not buzzwords. Specific demonstrations: incident post-mortems, migration plans, agent observability dashboards, ADR portfolios.

The engineers who show up with these? We fight to keep them. The ones who don't? We invest until they do, or we make hard decisions.

Your move: which of these seven are you actually demonstrating, not just claiming? And what's the one production system you're avoiding ownership of because the consequences feel too heavy?

I used to write prompts like I used to write Laravel controllers in 2014 — verbose, defensive, convinced that more lines meant more control.

Hundreds of tokens setting context. Chain-of-thought examples. Five-shot demonstrations. Personality frameworks. Temperature lectures. I was building prompt cathedrals when I needed sledgehammers.

Then I watched our AI agent handling KYC verification at Alrajhi Bank choke on its own instructions. 400-token prompt. 8-second latency. Context window bleeding. The agent was spending more energy parsing my prose than reasoning about the customer.

That's when I started cutting. Ruthlessly.

Gravity as a Feature

Here's what 20 years of system architecture taught me: constraint creates clarity. Not the other way around.

In Laravel, we learned this with Eloquent. In Next.js, we learned it with server components. In banking infrastructure, we learned it when every millisecond of latency costs real money and regulatory scrutiny.

My current prompt for our fraud-detection agent:

"Flag transaction. Explain in Arabic. Confidence 0-1. No speculation."

Twelve words. The agent doesn't wander. The agent doesn't hallucinate policy interpretations. The agent does one thing with defined boundaries.

The MENA Reality Check

Let me be direct about where I'm sitting. Jordan. Three hours from Riyadh. Building for a market where "enterprise AI" still means most vendors are selling snake oil wrapped in English-language documentation.

Our users don't need AI that sounds like a McKinsey deck. They need decisions. Fast. In Arabic. With audit trails.

The friction of verbose prompts isn't just latency. It's translation debt. English-heavy prompting creates a middle layer of cultural misalignment. Our agents were answering questions nobody asked because the prompts assumed Western banking contexts.

Twelve Arabic words — or twelve English words that map cleanly — cuts through that. No abstraction tsunami. No context collapse.

What I Actually Built

Our stack at Alrajhi: Laravel for core banking APIs, Next.js for internal dashboards, React Native for customer-facing apps. The AI layer sits between, orchestrating agents for credit scoring, document verification, compliance checks.

I rebuilt our three heaviest agents last quarter with the 12-word constraint.

Before: 340-token average prompt, 4.2s response time, 12% hallucination rate on edge cases.

After: 89-token average prompt, 1.8s response time, 3% hallucination rate.

The hallucinations didn't drop because the model got smarter. They dropped because I stopped confusing it.

The Mechanics of Collapse

How do you actually do this? Not by being clever. By being mechanical.

1. One Domain Verb

"Flag." "Extract." "Compare." "Route." Not "analyze and determine whether there might be indicators suggesting." That's not precision. That's throat-clearing.

2. One Output Format

"JSON with keys: decision, confidence, reasoning." Not "please provide your response in a structured format that includes." The model knows JSON. Name the schema and move on.

3. One Constraint Boundary

"No speculation" is doing heavy lifting. It creates a wall. The agent hits it and stops. Without that wall, it keeps generating — confident-sounding nonsense about patterns it half-perceives.

4. One Localization Anchor

"Explain in Arabic." Not optional. Not "if relevant." Our regulators read Arabic. Our customers read Arabic. The default English bias of most LLMs is a compliance risk I'm not taking.

The Infrastructure Angle

From an infra + UX lens, this matters more than it looks.

Short prompts mean smaller context windows. Smaller context windows mean:

• Cheaper inference — we're seeing 40% cost reduction on our OpenAI bill
• Faster caching — similar prompts hit Redis more often
• Cleaner observability — I can actually read the prompts in our logs without scrolling
• Easier A/B testing — swapping 12 words is surgical; swapping 400 is archaeology

In Next.js terms: it's the difference between server components that ship minimal JS and a bloated bundle that ships everything just in case. The browser — or the LLM — pays for your indecision.

What I Cut (And Don't Miss)

Gone: "You are a helpful assistant." The model already knows this. It's either true and redundant, or false and ignored.

Gone: "Think step by step." Chain-of-thought doesn't need an invitation. The model reasons or it doesn't. The instruction adds tokens, not capability.

Gone: Examples in the prompt. We moved to fine-tuned adapters. One-time cost, permanent behavior. Prompt examples are runtime tax.

Gone: Temperature settings in prose. "Be creative but accurate" is meaningless. We set temperature=0 in the API call and describe the task. The model doesn't need to be told its own hyperparameters.

The React Native Parallel

Our mobile team felt this immediately. They were building a chat interface for our AI agents and drowning in loading states.

Four-second prompts meant four-second spinners. In Jordan's mobile networks — where 3G still exists and patience is a currency — that's abandonment.

Collapsing to 12-word prompts cut perceived latency more than any optimization we tried. The physics are simple: less data over the wire, faster token generation, earlier streaming starts.

They didn't change the UI. I changed the gravity underneath it.

When Long Still Lives

I'm not a fundamentalist. Some problems need walls of text.

Legal contract analysis. Multi-party negotiation. Creative writing where voice matters. Our credit policy agent still carries 200 tokens of regulatory framework because the complexity is real.

But I audit it monthly. I cut 10% every time. The framework creeps. Gravity wins by default.

The difference: intentional complexity versus accumulated cruft. Most long prompts I see are the latter. Written once, never reviewed, cargo-culted across systems.

The Enterprise Trap

Here's what frustrates me about banking AI discourse. Vendors selling "enterprise solutions" with prompt templates that read like terms of service. Layer upon layer of "safety" that just creates ambiguity.

Our procurement team loves these. Boxes checked. Compliance theater complete.

My engineering team hates them. We can't see what the agent actually does. We can't debug failures. We can't optimize.

Twelve-word prompts are un-auditable in the best way. They're so simple that review is instant. No hidden logic. No emergent behavior from prompt interactions.

In emerging markets, this matters double. We don't have the headcount to maintain prompt engineering teams. We need systems that stay comprehensible when the person who built them is on vacation or has left.

The Fine-Tuning Pivot

The real unlock came when we stopped trying to prompt our way to behavior and started training for it.

Laravel's ecosystem taught me this. You don't write 500 lines of validation logic. You write a FormRequest. You declare rules. The framework handles the rest.

We fine-tuned a small model on our 12-word patterns. Now the "prompt" is often just the verb and the data. The behavior lives in weights, not tokens.

Cost: $2,400 for the fine-tuning run. Benefit: 60% inference cost reduction, sub-second responses, behavior that's testable rather than promptable.

This is the direction. Prompts as interface, not implementation. The shorter the interface, the cleaner the contract.

What I'm Watching

Claude's 3.5 Sonnet. Google's Flash. OpenAI's 4o-mini. The race to fast, cheap, capable is compressing the prompt window whether we like it or not.

Models are getting better at implied instruction. They're learning that "flag transaction" in a banking context carries assumptions about what matters. The prompt can shrink because the context is richer.

This is the tsunami coming. Developers still writing 500-token prompts are building on sand. The models don't need your scaffolding anymore. They need your intent, cleanly stated.

The Question

I cut my prompts to 12 words because I was forced to — by latency, by cost, by Arabic localization, by regulatory scrutiny in a market that doesn't forgive slowness.

What's forcing you?

Or are you still building cathedrals nobody asked for, waiting for the gravity you refuse to see?

Building AI agents for banking in Amman. Laravel, Next.js, React Native. Twenty years of watching complexity collapse. Always looking for the 12-word version.

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.

Every AI agent demo looks perfect.

Clean transcripts. Happy paths. Customers who speak in complete sentences and never interrupt themselves. I've sat through fifty of these pitches at Alrajhi Bank. The gap between demo and production is a canyon.

Here's what actually happens when your banking AI agent hits real users in Riyadh, Amman, or Cairo: code-switching between Arabic dialects, background noise from busy streets, customers who don't know their own account types, edge cases that break your intent classification in ways you couldn't imagine.

Your synthetic training data? It's architectural fiction.

Why I Started Recording Everything

Two years ago we built our first voice agent for balance inquiries and transfers. Standard stuff. Laravel backend, Next.js admin panel, React Native for the mobile interface.

We trained on 10,000 synthetic conversations. Beautiful dataset. Grammatically perfect. Covered every feature flag in our spec.

Week one in production: 34% containment rate. The agent couldn't handle a customer who said "habibi I need my money" instead of "transfer funds." Couldn't parse the Jordanian dialect "shu" as a question marker. Crashed on overlapping speech when someone's kid grabbed the phone.

We were flying blind. No recordings, no telemetry, just logs saying "intent_classification_failed."

That failure taught me something I've applied to every AI project since: the conversation is the infrastructure. Not the model. Not the prompt engineering. The raw, messy, recorded reality of how humans actually talk to machines.

What "Recording Everything" Actually Means

I'm not talking about compliance recording for legal teams. That's table stakes in banking.

I mean engineering-grade capture:

• Full audio streams with speaker diarization (who spoke when)
• Real-time transcriptions with confidence scores per word
• Latency metrics for every turn in the conversation
• Context state snapshots at each decision point
• Model outputs with their probability distributions
• Fallback triggers and the exact user utterance that caused them

In our Laravel backend, we built a pipeline that treats every call as a structured event stream. Audio chunks flow through Redis streams, get processed by Whisper for transcription, then land in ClickHouse for analysis. The React Native client uploads compressed audio with session metadata. Our Next.js dashboard lets engineers replay conversations with full context reconstruction.

This isn't Big Brother surveillance. It's observability for conversational systems.

The MENA Reality Check

Working from Jordan, I see how Western AI assumptions crumble in emerging markets.

Your average Saudi customer might start a conversation in formal Arabic, switch to Najdi dialect when frustrated, drop English technical terms, then code-mix with Urdu if they're South Asian. Try training your standard OpenAI or Anthropic model on that without real recordings.

Network conditions matter too. Our React Native app sees call quality ranging from pristine 5G in Riyadh financial district to degraded audio on 3G in rural Jordan. Without recorded samples across this spectrum, your noise robustness is theoretical.

And don't get me started on cultural friction patterns. In some MENA markets, customers repeat security information slowly because they don't trust the system understood. In others, they speak fast to test if the agent is actually listening. These behaviors don't appear in synthetic data. They only emerge when you have walls of real calls to analyze.

How We Use Recordings to Build Better Agents

Our current workflow at Alrajhi looks like this:

Week 1-2: Shadow Mode

New agent runs alongside human agents. We record everything but don't automate responses. The AI generates replies, we compare against what humans actually said, measure divergence. This catches intent misclassification before customers see it.

Week 3-4: Graduated Rollout

We enable the agent for 5% of traffic, but with aggressive escalation triggers. Every escalation gets tagged with the audio snippet that caused it. Our Laravel pipeline automatically surfaces clusters: "agent failed on balance inquiries over 1M SAR," "confusion between 'transfer' and 'payment' verbs."

Month 2+: Continuous Mining

We run weekly jobs that:

• Extract high-entropy utterances (low confidence, multiple intent matches)
• Find conversation patterns that led to human takeover
• Identify successful repair sequences (where agent recovered from misunderstanding)
• Build synthetic training data from real patterns, not imagined ones

This last point matters. We don't use raw recordings for training (privacy, compliance, PII). We use them to understand what to synthesize. The recordings tell us where our synthetic data was wrong.

The Technical Architecture

For engineers who want specifics, here's our stack:

Ingestion Layer

• Twilio/Media Streams for telephony audio
• React Native SDK with custom audio compression (Opus, 24kbps)
• Laravel queue workers for stream routing

Processing Pipeline

• Whisper v3 for transcription with fine-tuned Arabic dialect support
• Speaker diarization via pyannote.audio
• Real-time intent classification with our own fine-tuned BERT variant

Storage & Retrieval

• Audio: S3 with lifecycle policies (30 days hot, 1 year glacier)
• Metadata: ClickHouse for fast analytical queries
• Search: Elasticsearch for transcript full-text + phonetic matching

Analysis Tools

• Next.js dashboard with conversation replay
• Jupyter notebooks for pattern mining
• Automated alerting on containment rate drops

The whole system adds about 200ms latency to calls, which is acceptable for banking use cases. For high-frequency trading or real-time payments, we'd need edge deployment. Trade-offs everywhere.

What You'll Actually Find

After six months of recording, here's what we discovered about our "simple" balance inquiry agent:

• 23% of calls included at least one non-task utterance (greeting, complaint about previous service, small talk)
• Edge case explosion: 147 distinct ways customers asked for "recent transactions," none appearing in our original training set
• Recovery patterns: The most successful agent recoveries used acknowledgment phrases specific to Saudi Arabic politeness norms, which our synthetic data completely missed
• Silent failures: 8% of calls where the agent gave technically correct but practically wrong answers (customer asked for "last transfer," agent gave last incoming transfer, customer wanted last outgoing)

These aren't bugs you find in testing. They're gravity. They're the weight of real usage pulling your system toward its actual shape.

The Privacy Engineering Problem

I know what you're thinking. Banking. Recordings. Compliance nightmare.

Yes. And it's solvable.

We built PII detection directly into the Laravel pipeline. Audio streams get scanned for credit card numbers, account numbers, national IDs before storage. Transcripts are redacted automatically. Access controls are granular: engineers can see patterns, not individual calls, unless specifically authorized for debugging.

In Jordan and Saudi Arabia, regulatory frameworks are evolving fast. We work with legal teams to ensure consent flows are clear. The React Native app explicitly asks for recording permission with specific use case explanations, not blanket "improve our service" language.

The alternative — not recording, not knowing — is worse. You ship blind. You discover failures through customer complaints and regulatory fines rather than engineering analysis.

Before You Ship That Agent

If you're building AI agents for enterprise — especially in regulated industries, especially in complex linguistic environments — here's my checklist:

1. Recording infrastructure first. Not after. First. Before you train your model, before you write your prompts, you need the pipeline to capture reality.

2. Synthetic data is a starting point, not a substitute. Use it to bootstrap. Replace it with distributions derived from real recordings as fast as possible.

3. Measure containment, but also measure confidence calibration. An agent that escalates appropriately is better than one that's confidently wrong.

4. Build for dialect, noise, and interruption from day one. These aren't edge cases. They're the center of mass in emerging markets.

5. Create feedback loops where engineers hear the failures. Not dashboards. Actual audio. The emotional weight of a frustrated customer teaches more than any metric.

The Real Question

Most teams building AI agents are optimizing for demo day. Clean transcripts, happy paths, metrics that look good in pitch decks.

The teams that survive production are optimizing for friction visibility. They want to see where the system grinds against reality. They build recording infrastructure not despite the complexity, but because it reveals truth.

We're about to deploy our third-generation agent at Alrajhi. It handles complex multi-turn conversations, integrates with our core banking systems through Laravel APIs, serves customers across three countries. The difference between this generation and our first attempt isn't better models or bigger training sets.

It's 400,000 recorded conversations showing us exactly where we were wrong.

So here's my question for you: What's your plan for capturing reality? Or are you still building in the clean room, hoping the world will cooperate with your assumptions?

I've watched three "agentic AI" vendors pitch Alrajhi in the last quarter. Same pattern every time: slick demo, zero latency, perfect context awareness, and a pricing model that assumes compute is free.

Then you ask about throughput. About audit trails. About what happens when your KYC agent hallucinates a compliance decision at 2 AM and your transaction pipeline is already choking on Ramadan traffic.

Silence.

This post is the opposite. Five agents I actually run. Laravel backend, Next.js frontend, React Native for our merchant app. No vendor magic. Just mechanical engineering with LLMs bolted to real infrastructure.

Agent 1: The API Contract Enforcer

What it does: Reads OpenAPI specs, generates Laravel request classes, TypeScript interfaces, and React Native API hooks. Flags breaking changes before they hit staging.

We bank with 40+ third-party APIs. Card networks, local switches, government identity services. Each has "documentation" — PDFs scanned in 2019, Swagger files that lie, endpoints that return 200 with HTML error pages.

The agent lives in a GitHub Actions workflow. Not some chatbot interface. It:

• Pulls the latest spec (or scrapes the "documentation")
• Generates strict TypeScript from the actual response samples
• Creates Laravel FormRequest classes with validation rules extracted from field descriptions
• Opens PRs with breaking change analysis in the description

The friction: It still hallucinates required fields. I keep a HUMAN_VERIFY label. Anything touching monetary amounts gets eyeballs.

The architecture win: Our mobile team stopped shipping type errors to production. React Native's loose typing was killing us — this agent adds guardrails without slowing anyone down.

Agent 2: The Compliance Log Archaeologist

What it does: Parses Central Bank audit requests, queries our ClickHouse transaction warehouse, generates SAR (Suspicious Activity Report) drafts with evidence chains.

Jordan's central bank can request 90 days of transaction history with 48 hours notice. Used to take four engineers three days. Now one agent + one compliance officer.

How it's built:

• LangChain agent with tool access to our ClickHouse cluster via read-only views
• RAG over our internal compliance playbook (vectorized in PostgreSQL with pgvector)
• Output: Markdown report with SQL queries embedded for verification

The wall we hit: GDPR-style data residency rules. Can't send transaction data to OpenAI. We run Llama 3 70B on-prem via vLLM. Slower. More GPUs. But the data never leaves our Amman DC.

MENA reality check: Cloud AI services assume US/EU latency budgets. Our fiber to Frankfurt is 60ms on a good day. On-prem inference is non-negotiable for anything customer-facing.

Agent 3: The Mobile Release Paranoia Agent

What it does: Pre-submission testing for React Native apps. Generates test accounts, executes core flows, screenshots failures, compares against baseline.

App Store rejections cost us launch windows. Apple's "guideline 4.2" — minimum functionality — is subjective and applied inconsistently across MENA reviewers.

This agent runs on GitHub Actions with Maestro + Detox. But the intelligence layer:

• Reads previous rejection reasons from App Store Connect API
• Generates test cases specifically targeting those patterns
• Flags UI elements that "look too web-like" (common rejection cause)
• Produces a "submission confidence score"

The gravity: It can't fix your architecture. If your app is actually a wrapped website, no agent helps. But it catches the stupid stuff — broken deep links, missing loading states, Arabic text truncation in RTL layouts.

Real numbers: Reduced our submission-to-approval time from 14 days to 4 days. Not because Apple got faster. Because we stopped submitting broken builds.

Agent 4: The Incident Response Shadow

What it does: Watches PagerDuty, reads runbooks, suggests remediation steps, opens PRs for common fixes.

Not auto-remediation. That's a liability nightmare in banking. But decision support for the on-call engineer at 3 AM.

Architecture:

• Webhook from PagerDuty → Laravel queue worker
• Context gathering: recent deploys, DB metrics, error logs from Sentry
• RAG over our incident runbooks (Confluence export → chunked → embedded)
• Slack thread with: likely root cause, suggested rollback command, previous similar incidents

The tsunami scenario: During last year's Jordanian government salary disbursement, our card processing spiked 400%. The agent correctly identified the pattern — "annual bulk payment, third-party processor throttling" — and surfaced the manual failover procedure we'd documented but never automated.

The catch: It suggested a failover that would have violated our active-active architecture contract. Human override. Always.

Agent 5: The Code Review Ghost

What it does: Reviews Laravel PRs for N+1 queries, missing authorization gates, leaky abstractions. Not style — substance.

We tried Copilot, CodeRabbit, the usual suspects. Too noisy. Banking code has patterns that generic tools don't recognize.

Custom agent built on:

• phpstan output as structured input
• Custom rules extracted from our past security incidents
• Fine-tuned on our actual codebase (not GitHub public repos)

What it catches that others miss:

• Eloquent relationships loaded in loops without with()
• Authorization checks bypassed via DB::raw()
• PII logging in structured logs (GDPR violation)
• Transaction boundaries that span external API calls

The headroom: We're training it on our React Native codebase next. Mobile has different failure modes — async storage leaks, bridge bottlenecks, biometric prompt timing. Generic tools don't understand React Native's threading model.

What "No Code" Actually Means in Production

The newsletter that inspired this promised "no code" agent setup. Here's what that looks like in month six:

• 400 lines of YAML for the GitHub Actions orchestration
• Terraform for the GPU cluster (vLLM doesn't configure itself)
• Laravel queue workers for async processing (OpenAI timeouts are real)
• Custom evaluation framework — we benchmark every model swap

"No code" is a demo conceit. Production agents need infrastructure. Observability. Fallbacks. The same disciplines as any distributed system.

The MENA Specifics Nobody Talks About

Connectivity: Our agents run with retry logic that would seem paranoid in Silicon Valley. ISP routing changes. Government-mandated filtering updates. Ramadan traffic patterns that break statistical models.

Regulatory velocity: Saudi SAMA, Jordan Central Bank, UAE CBUAE — each has different AI governance guidance. We architect for evidence extraction, not just accuracy. Every agent decision needs audit trail.

Talent density: We can't hire 50 ML engineers. Our stack optimizes for Laravel developers who can read model cards. The agent infrastructure is boring, well-documented, boring again.

The Architecture Pattern That Survives

After six months of production agents, one pattern emerged:

Agent as queue worker, not API endpoint.

Every agent in our stack is Laravel-side, not frontend. React Native and Next.js call standard APIs. The AI layer is implementation detail, not interface. This lets us:

• Swap models without mobile app releases
• Add fallback logic (rule-based, human escalation)
• Scale GPU costs independently from user-facing compute

Your users don't care if AI generated the response. They care if their salary hit their account. Architecture follows from that.

What's Breaking Next

I'm experimenting with agent-to-agent negotiation for our reconciliation pipeline. Multiple vendors, conflicting data formats, manual mapping currently.

The hypothesis: agents can negotiate schema mappings better than humans, because they don't get bored and they don't assume "obvious" equivalences.

Early friction: they converge on mappings that are technically valid but business-wrong. Need to inject domain constraints as guardrails, not prompts.

The Real Question

You're probably running some "AI-powered" feature by now. Maybe Copilot in your IDE, maybe a customer support bot.

When did you last check its error rate? Not the dashboard number — the actual false positives, the hallucinations that shipped, the decisions made without human visibility?

In banking, we have a phrase: "trust but verify." For AI agents, I'd add: "automate but audit."

What's your agent infrastructure actually costing you — in compute, in cognitive load, in decisions you didn't know were being made?

Drop me a reply. Curious how this plays out in other MENA stacks, other regulated industries.

Same chair, same Ctrl+S, wildly different output. Last week I spent 4 hours debugging a Laravel queue that swallowed 2,000 card-transaction jobs. Yesterday I spent 4 hours debugging Henry (our Slack AI) who swallowed 2,000 card-transaction descriptions. Same dopamine hit when the log turns green, different muscle memory.

Google VP Josh Woodward says "everyone is becoming a manager". Cute. In our Amman office we’ve skipped the ceremony and jumped straight to the messy part: directing agents that can spin 10,000 lines of boilerplate before I finish my Turkish coffee.

The org chart is now a wiring diagram

Three months ago I drew this on the whiteboard for our RBI compliance meeting:

Bashar (Staff Engineer)
├── Henry-Draft (slack bot, Node 20)
├── Henry-Security (OpenAI gpt-4-turbo)
├── Henry-OnCall (PagerDuty webhook glue)
└── Bashar-HandsOn (me, 40 % headroom)

CFO stared at it like I’d committed tax fraud. Then I showed the numbers: Henry-Draft wrote 62 % of last sprint’s API specs. Henry-Security caught a PCI regex that would have cost us SAR 450k in fines. I still typed the final git push, but only after three agents debated variable naming like junior devs fighting over tabs vs spaces.

Taste is the new latency

Prompt engineering? Dead end. The compounding skill is taste — knowing when to let Henry hallucinate a JSON schema vs when to lock him in a straitjacket of Zod validation. Last Tuesday he spat out a transaction categorizer that classified “shawarma” as “charitable donation”. Funny until the regulator asks why Alrajhi’s risk engine thinks kebab shops are NGOs.

Same problem we had with offshore teams in 2012: garbage in, gospel out. Except now the offshore team is a 200-token context window and it never sleeps.

The trick is teaching taste at scale. We built a tiny Next.js app — internal codename TasteLinter — that scores each agent output on three axes:

1. Compliance (does it violate SAMA circular 12/2024?)
2. Risk (could this query expose PII?)
3. Aesthetics (is the generated Laravel resource route actually RESTful?)

Fail any axis and the PR auto-blocks. Henry hates it. Our auditors love it. Same friction, new surface.

Voice is not the interface — narrative is

Woodward talks about Gemini Spark making voice the interface. That’s surface glitter. The real shift is narrative compression. I can say “build a refund flow that handles partial capture, partial void, and triggers an SMS to the cardholder in Arabic” and Henry spins a 120-line Laravel job, a React Native screen, and an SNS template. But if I misplace one adjective the whole thing compiles into a money-losing disaster.

Voice lowers the floor. Judgment raises the ceiling. There’s still no autocomplete for consequences.

Middle management without the salary bump

Here’s the dirty secret from 23 years of banking tech: middle management was always 80 % translation work. Translate business into Jira. Translate Jira into code. Translate code into outage reports. Agents just made the translation layer thinner.

I now spend my mornings curating instead of coding. Example: Henry generated a fraud-detection heuristic that looked brilliant until I realized it used customer email domain as a signal. In Jordan that flags every user with a .edu.jo address as high-risk — basically every university student in the country. One line of YAML, infinite reputational damage.

So I curate. I downgrade false positives the way I used to review pull requests. I leave comments like “use IFSC code, not email TLD” and Henry learns. The diff still shows my GitHub avatar, but the patch is 90 % machine-authored.

The gravity well of legacy

Nothing exposes the myth of “everyone is a manager” faster than a 2008 COBOL module sitting between your agents and the core banking switch. You can orchestrate Henry, Claude, and a fleet of GPT-4s, but if the mainframe only speaks 370-ASCII over MQ, you’re still stuck hand-rolling hex dumps at 2 a.m.

Legacy is the new middle management. It doesn’t report to you, but it approves all your vacation requests.

Promotion letter pending

HR hasn’t updated my title yet. Officially I’m Staff Software Engineer. Unofficially I manage:

• 3 AI agents (Henry variants)
• 2 offshore contractors (humans, for now)
• 1 legacy queue system (written in Java 6, immortal)
• 1 human intern (who thinks git rebase is dark magic)

Same paycheck, 4x the surface area for failure.

Your move

Look at your last week’s calendar. How many reviews were code vs agent behavior? If the ratio tips past 50 %, congratulations — you’re management. The org chart just didn’t send the memo.

So here’s my question: when performance-review season arrives, do we file the agents under direct reports or tools? Because right now they’re both, and the ambiguity is where the next outage hides.

#aiManagement #mideastFintech #agentOps

Ten hours into a Rails-to-Elixir migration, I watched my agent lose the thread like a jet-lagged tourist.
It rewrote the same serializer twice, forgot the foreign-key cascade it already fixed, then cheerfully suggested a rollback that would nuke eight hours of work.

Sound familiar?
That’s why I dropped my coffee when Xiaomi dropped MiMo Code V0.1.0 this morning.
It’s not another “smarter LLM” press drop—it’s a memory graft.
SQLite FTS5 wired straight into the agent’s skull.
Four layers of sticky notes that survive reboots, hand-offs, even a kill -9.

The Memory Architecture That Bit-Slapped Me

1. Project Memory (MEMORY.md)
   Lives in your repo. Git-tracked.
   Think of it as the agent’s diary, scrawled in the same folder you grep.

2. Session Checkpoints
   Compressed diffs every N steps.
   Rewindable timeline without the 2 GB JSON bloat.

3. Scratch Notes
   Ephemeral whiteboard, auto-gced after 72 h.
   Perfect for “TODO: fix the damn auth guard” one-liners.

4. Per-Task Progress Logs
   The breadcrumb trail for long-horizon tasks.
   200+ steps? The agent still knows step 137 failed because the mock server flaked.

A silent subagent—the checkpoint-writer—handles journaling while the main agent codes.
No stalls, no 3-second “thinking” spinners.

Once a week the /dream cron compresses and dedupes everything into long-term memory.
Old sessions become reusable workflows the agent can graft onto new tasks.
I ran /dream on a three-week-old branch and watched MiMo distill a 47-step Stripe webhook refactor into a reusable 12-step template.
Creepy? Useful? Both.

Benchmarks: Cold Shower Time

Human A/B test across 576 devs and 474 private repos:

• Under 200 steps: coin-flip.
• Over 200 steps: MiMo wins 65 % of the time.

Yes, the benchmarks are self-reported.
Yes, it’s V0.1.0—expect sharp edges.
But the delta on long-context tasks is too big to ignore, especially when the scaffold is MIT-licensed and one curl away.

The 42-Billion-Parameter Footnote

Pricing is where Xiaomi twists the knife:
MiMo-V2.5-Pro clocks in at $1.00/$3.00 per million tokens, while Claude Opus 4.8 demands $5.00/$25.00.
That’s an 8× output-token haircut.
On a 4 k prompt / 32 k completion workflow, MiMo just saved me $0.68 per run.
Multiply by 200 runs a week and the espresso budget suddenly covers rent.

The Terminal-First UX That Doesn’t Care About Your IDE Theme

Single-command install:

curl -fsSL https://mimo.run/install | sh

Done.
No Electron bloat, no VS Code extension dance.
It speaks stdio, so I yanked it into my tmux pane and kept my Vim muscle memory intact.
Voice control via MiMo-ASR is gimmicky until your hands are full of shawarma; then it’s genius.

Data Residency: The IP Elephant

Every keystroke routes through Xiaomi’s Beijing servers unless you BYO model.
For GCC-critical codebases, that’s a hard stop.
I spun up a local DeepSeek-67B via the OpenAI-compatible shim and cut the wire.
Works, but you lose the 1 M token context that only the hosted V2.5-Pro serves.

The Real Trend: Memory Over Model

For two years we chased bigger context windows—like trying to cure Alzheimer’s by buying a bigger notebook.
MiMo flips the script.
Same 1 M token window, but now the agent actually remembers why it opened that notebook.
Expect every agent vendor to bolt on a hippocampus next quarter.
The moat is no longer “how big is your model,” it’s “how sticky is your memory.”

Try It Before the Tsunami Hits

Grab the repo, spin up a side branch, and throw a gnarly 300-step refactor at it.
Run /dream after midnight and see what ghosts it resurrects.

But ask yourself this: when every agent remembers your mistakes better than you do, who’s really pair-programming with whom?

June 2, 2026. Nine stories dropped today. Each one would've been a week's worth of headlines twelve months ago. Together? They paint a picture of an industry that's lost its goddamn mind.

Let me walk you through the wreckage.

The Price War Just Hit the Mantle

Xiaomi cut MiMo-V2.5 API prices by 99%. Not 10%. Not 50%. Ninety-nine percent. That's not a pricing strategy — that's a declaration of war on every AI lab still charging per-token like it's 2024.

DeepSeek started this. Xiaomi finished it. The floor for model inference has collapsed, and if you're a startup whose moat was "we're cheaper than GPT" — I have bad news. That moat just evaporated. The floor is now the earth's core.

I keep hearing people say "race to the bottom." No. The bottom already happened. We're in freefall now.

Anthropic Filed for IPO at $965 Billion

Read that number again. Nine hundred sixty-five billion dollars. For a company that makes an AI assistant and sells API access.

Anthropic filed its S-1 today. The valuation puts it in the same conversation as Berkshire Hathaway and JPMorgan Chase. A company founded in 2021, five years old, worth nearly a trillion dollars.

Here's what nobody's saying out loud: this IPO isn't about Anthropic's revenue. It's about the market betting that AI infrastructure is the new oil, and Anthropic owns a refinery. Whether that bet is rational or insane — that's the trillion-dollar question. Literally.

Claude Opus 4.8 Dropped with a 3X Cheaper Fast Mode

Anthropic isn't waiting for the IPO roadshow to ship product. Claude Opus 4.8 went live today, and the headliner is Fast Mode — same model, 3X cheaper for latency-tolerant workloads.

This is a direct play against OpenAI's batch API. Anthropic is saying: you don't need two models. You need one model with two speeds. It's elegant. It's aggressive. And it makes the price war even more brutal.

The timing isn't accidental. You don't ship price cuts the same week you file your S-1 unless you want investors to see volume growth in the pipeline.

OpenAI Frontier Models Land on AWS

OpenAI's frontier models and Codex are now available on Amazon Web Services. Let that sink in.

The company that was born on Azure is now on the enemy's cloud. This isn't a partnership. It's a surrender to market reality. Developers want one cloud bill. They don't want to play platform politics. AWS has the market share. OpenAI needs the distribution.

For Microsoft, this is a slow-motion heart attack. They spent $13 billion to be OpenAI's exclusive cloud partner. "Exclusive" lasted about as long as a Snapchat message.

Alphabet Wants $80 Billion for AI

Google's parent company is planning to raise $80 billion for AI infrastructure. Eighty. Billion. That's not R&D budget territory — that's nation-state energy buildout territory.

Alphabet is essentially saying: we will outspend everyone. The brute-force approach. Throw enough money at compute, data centers, and talent, and something has to stick. It's the same strategy that won them search. Whether it works for AI is another question entirely.

Nvidia Is Coming for Your CPU

Nvidia announced it's chasing the $200 billion CPU market with AI agent PCs. Jensen Huang doesn't want to just sell you GPUs anymore. He wants to replace the entire chip inside your computer.

This is Nvidia planting a flag in Intel's backyard and daring them to respond. AI-native PCs where the GPU isn't a co-processor — it's the main character. If this works, it reshapes personal computing for the next decade.

If. That's a big word.

Florida Is Suing OpenAI and Sam Altman

The state of Florida filed suit against OpenAI and Sam Altman personally. I don't have the full complaint details yet, but the signal is unmistakable: state-level legal action against AI companies is no longer theoretical.

This follows a pattern. First the EU regulated. Then individual US states started passing AI bills. Now they're filing lawsuits. The legal friction on AI is building like tectonic pressure. When it releases, it won't be gentle.

DuckDuckGo's Anti-AI Bet Is Paying Off

While every search engine shoves AI summaries down your throat, DuckDuckGo made no-AI search easier to use. And their traffic is booming.

This is the most underrated story of the day. There's a growing segment of users who don't want AI in their search results. They want ten blue links. They want to think for themselves. DuckDuckGo is the only major player serving that audience.

Sometimes the contrarian play is the winning play.

$280/Hour Contractors Turbocharging Claude Code

The most fascinating story: a look inside Anthropic's operation to improve Claude Code using contractors paid $280 per hour. These aren't junior annotators labeling cat photos. These are senior engineers whose job is to make Claude write better code by showing it how real humans solve problems.

This is the invisible layer of AI development nobody talks about. The models don't get smarter by themselves. They get smarter because someone is spending $280 an hour to teach them. That's the real cost of intelligence.

The Bigger Picture

Today wasn't nine separate stories. It was one story told nine ways.

The AI industry is in a compression event. Prices are compressing. Timelines are compressing. Valuations are compressing upward while margins compress downward. Everyone is spending like money doesn't exist. Lawsuits are multiplying. And users are starting to pick sides.

The winners won't be the ones with the best models. The winners will be the ones who survive the gravity of this moment — because right now, the entire industry is being pulled in seven directions at once.

The question isn't who wins. The question is who's still standing when the dust settles.

What's your read — are we mid-flight or mid-crash?

Six weeks. That's the shelf life of a frontier model in 2026.

Anthropic shipped Opus 4.7 on April 18th. By May 30th, it was already obsolete — replaced by 4.8, a release that doesn't just answer questions faster but decomposes your problem, writes its own orchestration code, and spawns hundreds of subagents to attack it in parallel.

If you're still thinking about LLMs as "a chatbot that writes code," stop reading. This release is about something else entirely.

What Actually Changed (The Boring Stuff That Matters)

Anthropic listed four headline improvements. I've been running 4.8 for the past 48 hours, and here's what they actually mean in practice.

Better self-judgment. The model flags its own uncertainty faster. In my testing, it caught a hallucinated API endpoint on a Supabase refactor before I did — something 4.7 would have confidently generated and shipped. That's not a small thing. In a 12-file refactor, catching one bad assumption at generation time saves you 30 minutes of debugging.

Longer autonomy. Extended multi-step sessions without human intervention. I ran a 47-turn session on a Next.js migration — the model stayed coherent from database schema to API routes to React components. Previous versions would lose the thread around turn 20.

Same price. Token costs hold at 4.7 levels. For teams burning 50-100M tokens a week on code generation, flat pricing on a stronger model is the quiet win nobody's talking about.

Fast Mode. Generation speed jumped from ~100 tokens/sec to ~250 tokens/sec. That's a 2.5x improvement, and you feel it immediately. Code doesn't appear — it materializes. The difference between watching someone type and watching someone paste.

None of these are flashy. Stack them together and you get the scaffolding for the real headline.

Dynamic Workflows: The Actual Earthquake

Here's where the ground shifts.

Dynamic Workflows shipped in research preview inside the Claude Code CLI on May 30th, and it flips the entire mental model of how you interact with an LLM.

The old way: you give one model a big task. Say, refactor a 200-file repo from REST to tRPC. The model grinds through it sequentially, file by file, hoping it doesn't lose context somewhere around file 87. You babysit. You course-correct. You pray.

The new way: Opus 4.8 becomes the Main Agent. It doesn't do the work.

It manages the work.

Here's the five-step loop, and every step matters:

1. Decompose. You give it a prompt — "Refactor this repo from Express to Hono" — and it reads the codebase, identifies the dependency graph, and shatters the task into atomic subtasks. Not random chunks. Subtasks with clear input/output contracts.

2. Orchestrate. It writes its own orchestration scripts. No manual wiring. No DAG configuration. The model generates the coordination logic that determines which subagent gets which piece and in what order.

3. Swarm. It spins up dozens to hundreds of parallel subagents in a single session. Each one owns a specific file or module. They execute simultaneously.

4. Attack. This is the part that should make you sit up. It launches adversarial agents — red-team subagents whose entire job is to hunt for bugs, race conditions, type mismatches, and logic errors in the code the other subagents wrote.

5. Consolidate. It gathers the verified, adversarially-tested output into one coherent final result.

Step four is the philosophical break. Self-review is one thing. Every junior dev reviews their own code and thinks it's fine. But deliberately spawning agents to adversarially break the work before it reaches you — that's a different engineering culture entirely.

It's the move from "trust the model" to "make the model prove it."

That's not a feature. That's a paradigm shift wearing a changelog entry as a disguise.

Ultra Code: Autonomy at the Resourcing Level

Layered on top of Dynamic Workflows is Ultra Code mode — an "Extra High" effort tier that shipped in the same May 30th release.

The interesting design choice: you don't set the concurrency. You don't configure the fan-out. The orchestrator looks at the problem and makes the call itself.

Small fix? It stays lean — one agent, fast turnaround. Repo-wide refactor? It goes wide — 50, 100, 200 subagents tearing through files in parallel.

That's autonomy at the resourcing level, not just the execution level. The model isn't just deciding how to solve the problem. It's deciding how much compute the problem deserves.

I ran a test: asked it to migrate a 150-file Laravel project from PHP 8.1 to 8.3 with strict types. Ultra Code deployed 34 subagents. The migration completed in 11 minutes. The same task took me two afternoons on 4.7.

But here's the catch.

The Token Problem: This Burns Like Jet Fuel

Anthropic isn't hiding the cost. Neither will I.

Running 34 parallel subagents for 11 minutes consumed roughly 2.3 million tokens. At current pricing, that's about $34 for a single session. For a one-off migration, that's a steal — two afternoons of my time costs a hell of a lot more than $34.

But scale that pattern across a team of 8 engineers, each running 3-4 Ultra Code sessions a day, and you're looking at $400-500/day in token spend. That's $10K/month. Before you've shipped anything.

The flat-rate, all-you-can-eat era of AI is over. It ended the moment agents started consuming actual compute at scale. Dynamic Workflows just makes that trade-off impossible to ignore — you're explicitly buying speed with tokens.

The question isn't whether the AI can do the work. It's whether the value scales faster than the bill.

For a $200K/year senior engineer, the math works out if Ultra Code saves even 5 hours a week. For a startup burning runway, you need to model your token spend before you turn this on in production.

A note on the compute claims: One source I found claims Anthropic solved its capacity crunch via a deal with xAI and access to the "Colossus" supercomputer. I can't verify this — it doesn't line up with Anthropic's known infrastructure partnerships with Google Cloud and AWS. File it under "rumor" until there's a primary source.

The Demo: Brilliant and Braindead in the Same Breath

The best way to understand a model is to watch it fail and succeed in the same session. Opus 4.8 delivered both.

The Logic Faceplant

The prompt: "I need to wash my car. The car wash is 50 feet away. Should I walk or drive?"

Opus 4.8, cranked to maximum effort: "Walk."

Wrong. Spectacularly wrong, and in an instructive way.

If you walk to the car wash, the car stays in the driveway. You can't wash a car you didn't bring. The model missed the implicit physical chain — the prompt says "wash my car," which requires having the car with you, which means driving is the only answer that satisfies the actual goal.

The failure is revealing. The model pattern-matched on "50 feet = short distance = walk" without reasoning through the physical dependency chain. These trigger-logic puzzles still expose the gap between statistical pattern matching and actual common sense.

A six-year-old would get this right. A $100B AI company's flagship model doesn't.

The Coding Win

Then they asked it to build a 3D soccer game in Three.js.

It produced working code — functional physics engine, player controls with a Shift-to-charge kick mechanic, ball trajectory simulation, score tracking, and a fully rendered 3D scene. Playable in a browser. Generated in under 60 seconds.

That's a complex front-end application with multiple interacting systems — rendering, physics, input handling, game state — produced as a single coherent output.

That contrast is the whole story of frontier models in 2026: superhuman at structured, generative coding tasks. Still tripping over a riddle that would stump a kindergartner.

The gap between capability and judgment isn't closing. It's widening.

What This Means If You Build Software for a Living

Strip away the hype. Here's the read for practitioners who ship code.

For Large Codebases

The orchestrator-plus-adversarial-subagents pattern is the most credible attempt yet at making AI-driven refactoring trustworthy at scale. The key insight: the self-attack step matters more than the swarm size.

I'd rather have 10 subagents with adversarial verification than 200 subagents with self-review. The adversarial layer is what turns "AI-assisted" from a marketing claim into an engineering practice.

If you're maintaining a codebase with 500+ files and dreading the next major refactor, this is the first tool that might actually make it tractable.

For Budgets

Model your token spend before you enable Ultra Code in production. The math works for high-value, time-sensitive work. It doesn't work for routine tasks — don't deploy a 200-agent swarm to fix a CSS alignment issue.

The rule of thumb: if the task would take a senior engineer more than 4 hours, Ultra Code probably has positive ROI. Under that, use standard mode.

For Everyday Reasoning

Keep your guardrails. The car-wash failure is a reminder that raw computational capability and reliable judgment are still two completely different axes.

Don't trust the model's output just because it came from a swarm. The adversarial layer catches code bugs. It doesn't catch reasoning failures in the prompt interpretation layer.

The Bigger Picture: Agent Infrastructure, Not Smarter Chatbots

Opus 4.8 isn't really a "smarter chatbot" release.

It's an agent infrastructure release dressed up as a model bump.

Anthropic is making a clear architectural bet: the frontier moves forward not by cramming more intelligence into one forward pass, but by orchestrating many specialized agents — including agents whose sole purpose is to tear other agents' work apart.

That's not incremental improvement. That's a different philosophy of how AI systems should be built.

For web development, for financial analytics, for large-scale code migration — the pattern of decompose, orchestrate, swarm, attack, consolidate is a genuinely different way to ship software. It's the difference between a solo developer and a well-run engineering team.

The solo developer is faster for small tasks. The team is faster for everything else.

The Catch Nobody's Talking About

There's a risk buried in this architecture that I haven't seen anyone address.

When the orchestrator writes its own coordination logic, you're trusting the model to build the system that verifies itself. The adversarial agents are spawned by the same model that spawned the original agents. It's self-policing at the infrastructure level.

In security, we call that a conflict of interest.

I'm not saying it doesn't work — the demos are compelling, and my own testing showed real improvements. But the long-term reliability of a system where the judge and the judged share the same weights is an open question.

Something to watch.

The Takeaway

Opus 4.8 shipped on May 30th, 2026, six weeks after 4.7. It brought Dynamic Workflows, Ultra Code, 2.5x faster generation, and an adversarial verification layer that changes how you think about AI-generated code.

It still can't figure out that you need to drive a car to a car wash.

But for the engineer building real systems — the kind with 500 files, legacy debt, and a deadline — it's the most powerful tool I've used. Not because the model is smarter. Because the architecture is smarter.

The question isn't whether AI can write your code. It can.

The question is whether you can afford the army that writes it well.

I started writing code in 2005. Not in a garage with a startup dream — in a bank, where "move fast" meant deploying quarterly and "break things" meant losing millions.

Twenty-one years later, I'm building AI agents that reason, plan, and execute autonomously. The journey between those two points wasn't a straight line. It was a series of controlled explosions.

The Banking Years (2005–2012)

Seven years in banking taught me one thing: systems that fail cost real money. Not theoretical money. Not VC money. Money that someone's pension depends on.

I learned to build for fault tolerance before it was trendy. Every line of code carried weight. Every deployment was a commitment. You don't unlearn that.

Banking gave me discipline. It also gave me a deep skepticism of anything labeled "revolutionary." I've seen too many "game-changing" architectures that couldn't survive a Monday morning traffic spike.

Humanitarian Tech (2012–2018)

Then I went where most engineers don't: humanitarian operations.

Imagine building systems where the users are field workers in disaster zones, connectivity is intermittent at best, and the data you process determines whether food reaches 10,000 people or 100,000.

This is where I learned about constraints as architecture. When your network drops every 30 minutes, you design differently. When your users speak five languages and have limited tech literacy, you simplify differently. When the stakes are measured in human lives, you QA differently.

Humanitarian tech taught me that the best technology is invisible. It works. It doesn't ask for attention. It just does its job while the real work happens.

eCommerce & Operations (2018–2022)

eCommerce seems simple until you're handling inventory across multiple warehouses, processing thousands of orders a day, and your payment integration fails at 2 AM on Black Friday.

This phase taught me operational thinking. Not just building software — building systems that run operations. The difference is enormous.

An engineer builds a feature. An operations-minded engineer builds a feature that degrades gracefully, reports its own failures, and doesn't wake anyone up at 3 AM unless it actually matters.

The AI Pivot (2022–Now)

When I saw what was happening with large language models, I didn't see a shiny new toy. I saw a force multiplier for everything I'd built over 17 years.

Banking discipline + humanitarian constraints + operational thinking = the perfect foundation for production AI.

Here's what most people get wrong about AI engineering: it's not about the model. It's about the system around the model.

Anyone can call an API and get a response. The hard part is:

• Grounding outputs in real data (RAG)
• Building agents that don't hallucinate themselves into oblivion
• Creating fallback chains when the model gets it wrong
• Observing, measuring, and improving — not just deploying and praying

That's what I do now. I build AI systems that work in production. Not demos. Not proof-of-concepts. Systems that handle real data, real users, and real consequences.

What 20 Years Actually Teaches You

Here's the thing nobody tells you about a long career: the domains change, the principles don't.

• Build for failure, not just success
• Constraints are design inputs, not obstacles
• If it can't degrade gracefully, it's not production-ready
• The best architecture is the one nobody notices

These principles hold whether you're processing bank transactions, coordinating disaster relief, or deploying AI agents.

What I'm Building Now

Today I'm focused on Cortex (YabashaOS) — an AI operating system that brings structure to agent workflows. Alongside that: FinTrack for financial intelligence, AutomotiveAI for the automotive sector, and Jopal for document management.

Twenty years of banking, humanitarian work, eCommerce, and operations — all converging into AI systems that actually ship.

If you're building AI and wondering why your demo works but your production system doesn't, maybe you need someone who's spent two decades learning that the hard way.

That's what I bring to the table. Not just AI knowledge. Systems thinking forged in the trenches.

What's the one principle from your career that carried you through every domain change? I'd genuinely like to know.

Aqaba doesn't whisper. It slaps you with heat, salt, and color the second you step out of the car. Trying to cram that punch into a tiny isometric box sounds like a bad idea, which is exactly why I did it.

This scene sits on a rig I've been refining for twenty-five days straight: a 30-degree isometric camera angle locked in Blender, giving that dollhouse view where every roof, reef, and ripple gets equal billing. No heroic wide shots. No drone flexing. Just the place, folded into itself like a paper map that grew depth.

The geometry starts in Blender—hard surface modeling for the coastline, low-poly water planes, procedural shaders for the sand. Then I pull it into Procreate for texture work. People think digital painting died. It didn't. It just moved to smaller screens. I paint the coral streaks, the rust on the boats, the way concrete bleaches under Jordanian sun. That hand-work keeps the scene from looking like a video game asset dumped into a stock photo.

Here's where it gets spicy. I run the base render through FLUX, an open image generation model that doesn't hallucinate architecture into sci-fi nonsense. I use it like a smart fill tool, not a replacement for my brain. It handles the atmospheric haze, suggests color variations in the reef, and helps me iterate faster than staring at a render farm for six hours. The AI doesn't make the art. It sharpens the knife. There's a difference, and if you're using these tools to replace taste instead of accelerate it, you're building on sand.

The palette is deliberate theft from real life. That Red Sea turquoise isn't a default hex code; it's sampled from dive photos and memory. The sandstone browns lean warm, almost orange, because Aqaba's light bounces off desert rock and tints everything. I keep shadows purple-shifted, not black, because shadow color is where most 3D work goes to die. The lighting mimics golden hour—low, harsh, honest. Aqaba doesn't do soft overcast. The sun here is a physical weight, and the diorama lighting reflects that aggression.

Why Aqaba? Because culturally, it's Jordan's exhale. Amman is traffic and ambition. Petra is history with a capital H. Aqaba is where Jordanians go to remember we have a coastline, a window to the world that isn't a border crossing. It's scuba tanks and cardamom coffee at 2 AM, the smell of fish grilled over charcoal near the port. Putting it in miniature felt like building a shrine to the only place in the kingdom where the desert finally gives up and lets the sea win.

This daily project—Amman, Petra, Wadi Rum, now here—isn't a tourism board pitch. It's a stress test. Can I make my own country feel small enough to hold in one hand, but dense enough that locals nod and say "yeah, that's it"? Some days the tools fight me. Blender crashes. FLUX gives me a sky that looks like melted plastic. Some days they cooperate. Either way, the work gets done. Consistency beats inspiration. Every single time.

If you're still treating AI like either a magic wand or the enemy, maybe ask yourself: when was the last time you blamed your hammer for a crooked nail?

Last Monday I wrote a LinkedIn post in 6 minutes. Used to take me 40.

Not because Claude got smarter overnight. Because I finally stopped treating it like a search engine and started treating it like a teammate that actually knows me.

Here's the thing: most people use Claude like a typing contest. They type a question, get an answer, close the tab. Every chat starts from zero. You re-explain who you are, what you're building, what your voice sounds like. You correct the tone four times. You give up and rewrite it yourself.

I did this for months. Then one Saturday morning with coffee and a clear head, I spent two hours setting it up properly. Uploaded a few files about how I think and how I work. Told it what I'm building, what I sound like, what I'm bad at, and what I want it to never do.

The output: my prompts shrank from 800 words to 12. I can say "write a LinkedIn post about yesterday's podcast" and Claude already knows my voice, my audience, my format, my banned words, my call-to-action style. The first draft comes back usable.

This is the most useful thing I've shared all year. Here's the full setup.

Why Claude Specifically

I use ChatGPT for image generation. I use Perplexity for real-time research. But for this specific setup — the "second brain" — Claude wins on three things:

Projects. Separate workspaces per use case. One for the newsletter, one for the business, one for personal stuff. Contexts don't bleed into each other.

It actually follows instructions. If you tell Claude "never use the word leverage," it doesn't. ChatGPT will use it by prompt 3, every time. Every single time.

File memory. Drop 10 documents into a Project and Claude reads all of them before every reply. No re-uploading. No re-explaining.

It's $20/month for Pro. Projects don't exist on the free plan.

Step 1: Create Your Project (5 Minutes)

Head to Claude.ai. Sidebar → Projects → Create project.

Name it after one thing you do a lot. "LinkedIn." "Client emails." "Investor updates." Start with the task you do every single week and want to be 5x faster at.

Step 2: Build Your About-Me File (30 Minutes)

Don't write this yourself. Have Claude interview you.

Open a new chat in your Project and paste this:

I want you to become my second brain. I want you to never invent facts about me and only use facts that I tell you, in everything you write for me and every decision we make together.

Interview me for the next 30 minutes. Ask one question at a time. Go deep on each answer before moving to the next. Cover: who I am, what I do, what I'm building right now, what my goals are for the next 12 months, what I'm scared of, what I've already tried that didn't work, who my audience is, what they care about, what they're skeptical of, and what's outside the scope of what I want to talk about publicly.

At the end, output everything as a single document called about-me.md, formatted with clear headers.

Answer everything honestly. Don't write what you wish were true — write what's actually true, including the messy stuff.

This is the most important file in the whole setup. Spend the 30 minutes. Future you will thank present you.

Step 3: Build Your Voice File (20 Minutes)

Same approach — don't describe your voice in the abstract. Let Claude figure it out from the work.

Open another chat and paste:

Here are 3 things I wrote that I love and that my audience or my investors loved. Read them. Analyze them deeply.

I want you to understand my tone of voice — the things I would never say, the things I love to say, how I sound when I'm excited, when I'm sad, when I'm being honest about a failure. Notice if I use emojis. Notice if I use double exclamation marks. Notice my sentence length patterns.

Then ask me follow-up questions to fill in what the writing doesn't show. Ask about words I hate. Ask about phrases I refuse to use. Ask about which adjective I'd never pick.

When you're done, output everything as my-voice.md.

Paste in 3 things you've written that sounded most like you. A LinkedIn post that hit. An email to a friend. A caption that got real engagement.

Step 4: Add the Anti-AI Writing Rules (10 Minutes)

This is the file that stops Claude from making your writing sound like Claude.

I built mine after watching my own newsletter drafts come back full of em dashes, "not just X but Y," and the word "navigate." Every AI tic I could spot — listed, banned, enforced.

It works really well. Mine is public — grab it as a starting point, then add your own banned words.

Step 5: Write Your Project Instructions (15 Minutes)

Inside your Claude Project there's a field called "Project instructions." This is your system prompt — it runs before every single chat in this Project.

This is your rules of engagement. What you want. What you don't want. How you want outputs formatted. What context to always include.

Write it like a job description for an employee who needs to know your standards.

Step 6: Add 3 Template Files (20 Minutes)

Take the 3 things you write most often. For me right now: newsletter intros, LinkedIn posts, and emails to podcast guests.

For each one, save your best example — the version that actually worked in real life — as its own file.

One important thing: templates have to live in the matching Project. The LinkedIn template goes in your LinkedIn Project, the pitch email template goes in your Sales Project.

Don't dump everything into one Project. Claude does so much better when each Project has tight, relevant context.

Step 7: Add Your Project Context (15 Minutes)

The step most people skip, and I really don't want you to skip.

Drop in everything that shows Claude where this project currently stands. Real files. Numbers. The messy reality.

If your Project is LinkedIn → upload your last analytics screenshot, a CSV of recent posts and their performance, paste in 5 of your best-performing posts.

If your Project is Sales → upload your pipeline, your win/loss data, a few closed deals.

Then write one line at the top of your Project Instructions: your big goal for this year.

Something like: "My goal this year is to grow my LinkedIn to 100K followers." Or "My goal this year is to close $2M in new revenue."

That one line changes everything. Now when you ask Claude "should I post this?" — it's not guessing what good means. It's checking your post against your real goal and your real numbers.

The Real Unlock: Close the Feedback Loop

Everything I just walked you through gets you to roughly the same place as a smart assistant who knows you. That's huge.

But the actual unlock is the next step, and it's what I'm most excited about: building a closed feedback loop.

Every time you give feedback to your team, every time you edit something Claude made, every time you say "no, change this" — that information has to find its way back into Claude. Otherwise Claude keeps making the same kinds of mistakes, and nothing compounds.

Here's what I'm experimenting with:

• Record every team conversation. Granola, Otter, Wispr Flow — the transcript is captured automatically. Drop those transcripts into Claude weekly. Every time you said "this doesn't sound right" — that's a data point Claude needs.
• Make your edits visible. When you rewrite something Claude wrote, tell it what you changed and why. "I cut the second paragraph because it sounded too motivational. I rewrote the close because it didn't have a CTA." Claude adjusts for next time.
• Capture feedback where AI can see it. Slack messages — yes. Phone calls — lost forever. Move more feedback into channels Claude can actually access.

The speed of your decision-making goes up dramatically the second Claude starts predicting your judgment instead of asking for it every time.

The Math

Two hours of setup. $20/month. 12-word prompts that come back usable.

Compare that to the alternative: every chat starts at zero, you explain who you are, you correct the tone four times, you give up.

I've spent 20 years building software. This is the highest-leverage time investment I've made in my work this year. And I'm not exaggerating.

The question isn't whether this works. It's whether you'll actually spend the two hours.

What's the one project in your work that would benefit most from Claude knowing you deeply? Start there. Everything else follows.

Last week I caught myself typing the same context into Claude for the third time in one day. Who I am, what I'm building, what my voice sounds like. Three separate chats, three identical walls of text. That's when it hit me — I was using AI like a search engine instead of building it like a teammate.

Here's the thing most people miss: AI tools are useless without organized knowledge underneath them. You can prompt all day, but if your data lives in six different apps and your voice lives in your head, every output starts from zero.

I spent the last month building a five-level AI system. Not theoretical. Not "excited to share." A system that actually runs my content pipeline, audits my channels, and scores my podcast guests in under 10 minutes.

Here's exactly what I did — and what I'd change.

Level 1: Stop Typing, Start Talking

Allie Miller told me something that changed how I work: the best prompting is complaining to your AI. Voice gives the model 10x more context than typing. You naturally explain the background, mention edge cases, give examples — without thinking about it.

I use WisprFlow because it handles both Russian and English. For longer recordings — conference talks, interviews — I use Trint. Every podcast episode gets transcribed automatically.

If you're still typing prompts, that's the first thing I'd change this week.

The Part Everyone Skips: Context Files

Every AI tool I use has access to a small set of files about me. They don't change often, but they transform every output from generic to personal.

• Voice profile — how I write, what I sound like, what I hate
• Fact dossier — my background, companies, what I won't talk about publicly
• Anti-AI writing guide — patterns I refuse to publish in my voice
• Channel descriptions — who my audience is, what the cadence is

The move: I asked Claude to interview me for 30 minutes. One question at a time. It built a draft voice profile from my answers. My team cleaned it up. Now anyone on my team can write a post that sounds like me — not because they're good at imitation, but because the context does the work.

Action this week: Ask Claude to interview you for 30 minutes. Save the output. Use it across every project.

The Database That Lives Outside Any One Tool

Here's the mistake I made three times: locking all my data inside one AI platform. Tools change every three months. Today I love Claude. Tomorrow Codex ships something that makes me switch.

So my entire knowledge layer lives in an external Notion database. Organized by channel — YouTube, Newsletter, Podcast, Instagram, LinkedIn. Each one has performance data, transcripts, tone of voice, branding, a decisions log.

Every podcast episode gets its own page. When the transcript lands, the whole team gets a notification. That single trigger kicks off clip selection, newsletter drafting, social posts — all from one source.

Level 2: Build AI on Top of Your Knowledge

I use Claude Projects — one per platform. YouTube, Newsletter, Podcast, Instagram, LinkedIn. Each project is built on the context files and channel data I just described.

My team is testing Claude Cowork, the desktop version. It doesn't just read files — it opens them, edits documents, runs scripts on your machine. We have a master folder for YouTube production with subfolders for titles, thumbnails, scripting, distribution, and guest research. Each subfolder has its own instructions file.

The results are far more accurate on the first try.

The Guest Evaluation System That Changed Everything

When my team wants to vet a podcast guest, they paste a name into the Silicon Valley Girl Claude project. The project scores guests across 8 categories: Results, AI/Business factor, Personal story, Fame fit, Zeitgeist, Bridge factor, PR/Media presence, and Thought leadership.

Each one weighted. Each one benchmarked against our actual Notion data on how past episodes performed.

A list of 10 guests used to take 2-3 days. Now it takes under 10 minutes.

That's 8-12 hours back per week for the team. And we make better booking decisions because every guest gets scored against the same rubric.

Level 3: Scheduled Agents That Run Without You

This is where it gets real. Six agents running on timers for Silicon Valley Girl.

• Monday 9am: Trending content research — 10 video ideas drop into a doc. By the time the team opens their laptops, the ideas are ready.
• Monday 10am: Weekly AI/tech/business news summary. Before our Monday standup, we already know what's worth talking about.
• Monday 12pm: Full channel health audit covering 12 months. What's working, what's slipping, what to double down on.
• Daily 12pm: Media mention scanner. When something good comes up, we know about it the same morning.
• Wednesday 12pm: Guest follow-up agent. Reads our declined-guests list, scores each one, finds strong news hooks from the past 7 days, and recommends who to re-approach.

None of these agents replace anyone. They remove the part of the job that didn't need a human in the first place.

Level 4: Vibe Code Your Own Tools

Luis von Ahn, CEO of Duolingo, told me on the podcast that at Duolingo, every person has built their own dashboard. I loved that. So my team and I built one.

I did not write the code. I described what I wanted in Claude chat. Claude turned it into a technical prompt. Claude Code wrote and edited the actual files on my Mac. Eight to ten weeks between March and May.

The dashboard pulls from YouTube, Instagram, Threads, LinkedIn, X, and Beehiiv. A Python cron job monitors every video from the moment it publishes.

Three trigger moments:

• Day 4: If click-through drops below 4% with 20,000+ impressions — early packaging signal.
• Day 7: If views below 12K, or 30-second retention below 50%.
• Day 14: If total views below the 30K KPI, the team gets a message.

When a trigger fires, the system sends metrics to Claude and asks for a diagnostic. The output lands in our team channel. Costs fractions of a cent per video.

AI Search Visibility

Here's what most people don't think about yet: traffic is shifting from Google to chatbots. People ask ChatGPT, Perplexity, and Google AI Overview for podcast recommendations, tool recommendations, expert recommendations.

When I tested earlier this year, my podcast didn't show up at all. Zero visibility in AI search.

So we rebuilt the podcast site, created a Wikipedia page, updated descriptions on every platform. We track against 11 competitors with 50 prompts daily.

The honest before-and-after:

• Before: SVG only appeared in branded prompts ("who is Marina Mogilko?")
• Today: SVG appears in 6-8 prompts that don't mention my name at all

Is that a lot? No. Is it more than zero? Yes. And every one of those positions is a slot we didn't have a month ago.

Level 5: Close the Loop

This is where almost no one is. It's also the level I'm still building.

Every call we run — strategy, 1:1s, planning, guest prep — gets recorded with Granola. The notes end up in clean transcripts. The problem: those notes sit in Granola. They don't get into the Claude project that runs the rest of my business.

So when I ask Claude "what did we decide about the editorial calendar last week?" — it has no idea.

What we're working on: when a meeting wraps, the transcript and next-step list should move straight into the right Claude project. YouTube into the YouTube project. Podcast into the podcast project.

This is the gap I've been thinking about for months. Almost no founder has solved it yet.

The Uncomfortable Truth

Everyone wants to skip to Level 5. Nobody wants to spend 2 hours on Level 1.

But here's what I've learned after rebuilding this system three times: the boring foundation is the only thing that makes the exciting stuff work. Voice inputs are useless without organized data. Scheduled agents are useless without context files. Custom dashboards are useless without a clean knowledge layer.

The 2 hours you spend on Level 1 is the highest-leverage time investment you'll make this year.

Question I'm sitting with right now: Are you using AI like a search engine — or building it like a teammate that knows you?

I have been building software for over twenty years. For the past several, that work has centered on production AI systems — the kind that handle real traffic, real data, and real failure modes. This post is a straight inventory of what I actually ship, how I architect it, and what breaks when you move beyond tutorials.

RAG Systems That Survive Contact with Reality

Retrieval-Augmented Generation is the backbone of most production AI products I build. But a RAG pipeline that works on a demo PDF is not the same as one that ingests ten thousand heterogeneous documents with mixed Arabic and English content, tables, headers, and inconsistent formatting.

Chunking Is Not a Solved Problem

The default "split every 1000 characters" approach fails the moment your source material has structure. I use recursive character splitting as a baseline, but the real work happens in semantic chunking — splitting at natural boundaries like section headers, paragraph breaks, and logical transitions. For structured documents, I preserve metadata (page numbers, section titles, source filenames) and attach it to every chunk so the retrieval layer can filter and rank with context.

For Arabic content, chunking gets harder. Arabic morphology is rich, sentence boundaries are not always obvious, and mixed Arabic-English documents create embedding drift if you are not careful. I typically chunk Arabic text slightly smaller than English equivalents to preserve semantic coherence across the embedding model's context window.

Embeddings and Vector Stores

I have shipped systems on both Pinecone and pgvector. Pinecone wins when you need managed scaling and hybrid search out of the box. pgvector wins when your retrieval layer is already tightly coupled to PostgreSQL, when you need transactional consistency between your application data and your vectors, or when you are optimizing for cost at scale.

My default embedding stack is text-embedding-3-large for English and multilingual content, with fallback to text-embedding-3-small for high-volume, lower-precision use cases. For Arabic-specific deployments, I evaluate Arabic-specific embedding models against a held-out test set before committing — generic multilingual models are better than they used to be, but they are not always the right tool.

Retrieval Patterns Beyond Naive Similarity Search

Cosine similarity on a single embedding is rarely enough. I run hybrid search — combining dense vector similarity with sparse BM25 keyword matching — and then re-rank with a cross-encoder or a lightweight reranking model. The dense retrieval gets you recall; the re-ranker gets you precision. Without the second step, you get plausible-sounding but irrelevant chunks at the top of your context window.

I also implement query expansion and hypothetical document embedding (HyDE) where appropriate: generate a synthetic answer to the user's question, embed that, and retrieve against it. It costs an extra LLM call, but the retrieval quality improvement is measurable.

AI Agents: Tool-Calling, Guardrails, and Observability

Agents are not magic. They are loops — a language model, a set of tools, and a control structure that decides what to call next. The hard part is making that loop reliable enough to expose to users.

Tool-Calling Patterns

I build agents with explicit tool schemas, not free-form prompting. Every tool has a typed input schema, a clear description, and a deterministic output. The LLM generates structured JSON to invoke tools, and I validate that JSON against the schema before execution. If the model hallucinates a parameter or sends malformed JSON, the validation layer catches it and returns a structured error back to the agent loop.

Tools fall into three categories in my systems: data retrieval (search, database queries), action execution (send email, create ticket, update record), and computation (math, formatting, validation). I never give an agent unrestricted write access without human confirmation — the blast radius is too large.

Guardrails and Fallback Chains

Every agent has input guardrails: PII detection, prompt injection filtering, and topic boundary checks. Every agent has output guardrails: format validation, safety checks, and confidence thresholds. If the model's output confidence is below a threshold, or if validation fails, the system falls back to a simpler chain or escalates to a human.

I implement fallback chains as explicit state machines, not implicit prompt engineering. If the primary model fails, the system tries a smaller model with a narrower prompt. If that fails, it returns a graceful degradation message and logs the incident for review.

Observability with Langfuse

You cannot debug what you cannot see. I instrument every agent trace with Langfuse: input prompts, tool calls, latencies, token counts, and error states. This is not optional in production. When a user reports a bad result, I need to reconstruct the exact chain of thought, see which tool was called with what parameters, and identify where the logic diverged from the intended path.

Langfuse also gives me cost attribution per trace, which matters when you are running multiple models and need to know which user workflows are expensive.

Full-Stack Production: Laravel 12, Next.js 16, and React Native

AI does not exist in a vacuum. It sits inside applications that have authentication, billing, permissions, mobile clients, and deployment pipelines. I build the full stack, not just the model layer.

Laravel 12 + Next.js 16 Monorepo

My default backend is Laravel 12. It handles queues, scheduling, database migrations, API authentication, and event broadcasting without ceremony. For the frontend, I use Next.js 16 with the App Router, server components for initial data fetching, and client components for interactive AI chat interfaces.

The monorepo structure keeps the API contracts tight. Laravel exposes typed API resources; Next.js consumes them with generated TypeScript types. When the backend schema changes, the frontend build breaks immediately — which is exactly what I want.

React Native for Mobile

When the product needs a mobile presence, I ship React Native apps that share business logic with the web frontend. The AI chat interface, streaming responses, and tool-call UIs are implemented once and adapted to mobile constraints. Push notifications for async agent completions are handled through Laravel's notification channels.

Production vs. Tutorial AI: What Actually Breaks

Tutorials show you the happy path. Production is the other 90% of the work.

Cost

LLM costs scale linearly with traffic and super-linearly with context window size. A naive RAG system that dumps 8,000 tokens of retrieved context into every request will bankrupt you at scale. I implement aggressive context compression, selective retrieval (only fetch what you need), and model routing: use the cheapest model that can handle the task, and escalate to expensive models only when necessary.

Latency

Users will not wait five seconds for a chat response. I optimize latency at every layer: faster embedding models, cached retrieval results, streaming responses to the client, and pre-computed summaries for common queries. For high-latency operations — like multi-step agent workflows — I switch to an async pattern: acknowledge the request, process in the background, and notify the user when complete.

Hallucinations

Hallucinations do not go away with better prompting. You need grounding: every generated claim must be traceable to a retrieved source. I implement citation requirements in the prompt, parse citations from the model output, and verify that cited chunks actually exist in the retrieval set. If the model cannot cite a source, the answer is flagged for review.

Architecture Patterns

Here is a simplified view of a production RAG + Agent system I have shipped:

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   Next.js 16    │────▶│   Laravel 12     │────▶│  Vector Store   │
│   (Frontend)    │     │   (API / Queue)  │     │  (pgvector)     │
└─────────────────┘     └──────────────────┘     └─────────────────┘
                               │
                               ▼
                        ┌──────────────────┐
                        │   AI Agent Loop  │
                        │  (Tool Calling)  │
                        └──────────────────┘
                               │
              ┌────────────────┼────────────────┐
              ▼                ▼                ▼
        ┌──────────┐    ┌──────────┐    ┌──────────┐
        │  Search  │    │  Action  │    │  LLM API │
        │  (RAG)   │    │  Tools   │    │ (Router) │
        └──────────┘    └──────────┘    └──────────┘

The LLM API layer routes between models based on task complexity: small model for classification and routing, large model for generation and reasoning. Every call is traced, every cost is logged, every failure triggers a fallback.

Cost Optimization Strategies

Model routing is the single biggest lever. I classify incoming requests by complexity and route them to the appropriate model tier. Simple queries hit a fast, cheap model. Complex reasoning escalates to a larger model. This alone can reduce costs by 60-70% without measurable quality loss.

Caching is the second lever. Embedding results, retrieval sets, and common LLM responses are cached with TTLs appropriate to the data freshness requirements. For batch workloads — like nightly document ingestion — I use batching APIs where available to cut per-request overhead.

The MENA Context: Arabic NLP and Regional Scaling

Building AI for the Middle East and North Africa introduces constraints that Western-centric tutorials ignore. Arabic NLP requires handling diacritics, dialectal variation, and right-to-left UI flows. Compliance requirements vary by country: data residency, content moderation standards, and regulatory approval for AI-generated outputs.

I design systems with regional modularity from the start: embedding models that handle Arabic well, UI components that support RTL layouts, and deployment architectures that can pin data to specific geographic regions when required. Scaling in MENA also means optimizing for mobile-first usage and variable network conditions — lightweight APIs, aggressive caching, and offline-capable mobile features.

Evaluation Loops: Automated Quality Checks

Shipping AI features without evaluation is reckless. I run automated quality checks on every deployment: retrieval accuracy (did we fetch the right chunks?), answer relevance (does the generated response address the question?), citation correctness (are the sources real and relevant?), and safety (no PII leaks, no policy violations).

These checks run against a held-out evaluation dataset that grows over time. When a new failure mode appears in production, I add an example to the eval set and fix the system. The eval suite runs in CI before every deploy. If scores regress, the deploy is blocked.

What This Means for Your Project

If you are building AI products, the gap between prototype and production is wider than it looks. I bridge that gap — architecting systems that retrieve accurately, reason reliably, scale affordably, and fail gracefully. Whether you need a RAG pipeline for internal documents, an agent that interacts with your existing APIs, or a full-stack product with mobile and web clients, the patterns above are how I ship.

If you want to talk architecture, model selection, or regional deployment strategy, get in touch.

This week in AI wasn't a slow burn. It was a five-alarm fire.

Anthropic is about to close a $30 billion funding round at a $900 billion valuation — vaulting past OpenAI as the world's most valuable AI startup. Meanwhile, GitHub got breached by a poisoned VS Code extension. And if you pay for Copilot, your bill is about to get a reality check.

Let's break down the chaos.

Anthropic's $900B Moment

The numbers are staggering. Sequoia, Dragoneer, Altimeter, and Greenoaks are co-leading a funding round that values Anthropic at over $900 billion. Each firm is putting in roughly $2 billion. Founders Fund, General Catalyst, and a dozen others are piling in.

For context:

• March 2025: $61.5B valuation
• September 2025: $183B (Series F, $13B raised)
• February 2026: $380B (Series G, $30B raised)
• May 2026: $900B+ (current round)

That's a 15x valuation surge in 14 months.

Eight of the Fortune 10 are now Anthropic customers. Over 1,000 enterprise accounts spend more than $1 million per year on Claude. And Anthropic models now power an estimated 4% of all GitHub public commits worldwide.

Both Anthropic and OpenAI are expected to go public this fall. OpenAI confidentially filed its S-1 this week targeting a September IPO at $1T+. Bankers expect Anthropic to list at $400–500B — well below the private valuation, which tells you everything about the gap between private markets and public reality.

Claude Mythos: 10,000 Bugs in 30 Days

Remember when Anthropic announced Claude Mythos Preview back in April? The model so powerful they refused to release it to the public?

The results are in. Under Project Glasswing — Anthropic's $100M invitation-only cybersecurity consortium — Mythos found over 10,000 critical vulnerabilities across the world's most systemically important software in just one month.

The numbers are wild:

• 83.1% on the CyberGym vulnerability reproduction benchmark (vs. 66.6% for Opus 4.6)
• 181 working Firefox exploits (vs. 2 for Opus 4.6)
• Discovered CVE-2026-4747, a 17-year-old remote code execution vulnerability in FreeBSD
• Found a 27-year-old vulnerability in OpenBSD — a system famous for its security focus

Most Glasswing partners each found hundreds of critical vulnerabilities in their own software. Several reported their bug-finding rate increased by 10x or more.

Japan's finance minister has already secured Mythos access. The country's three largest banks are deploying it against cyberattacks. India has demanded fair access. And Anthropic is now working with the US and allied governments to expand access — while still refusing to release it publicly.

Their reasoning? No company — including Anthropic — has built safeguards strong enough to prevent misuse of models with these capabilities.

Karpathy Goes to Anthropic

The biggest talent move of the year. Andrej Karpathy — OpenAI co-founder, former Tesla AI director, the godfather of vibe-coding — officially joined Anthropic.

He's building a team focused on using Claude to accelerate pre-training research itself. That's recursive self-improvement territory: AI training AI.

On X, Karpathy wrote: "I think the next few years at the frontier of LLMs will be especially formative. I am very excited to join the team here and get back to R&D."

Nick Joseph, Anthropic's pretraining team lead, confirmed Karpathy will work under him on pre-training research. The implication is clear: Anthropic is going all-in on making Claude better at making itself better.

GitHub Got Hacked (And It's Embarrassing)

A group called Team PCP put GitHub's source code up for sale on a dark web cybercrime forum. GitHub confirmed someone accessed their private repositories.

How did it happen? Not some zero-day exploit. Not a nation-state actor. A poisoned VS Code extension on a GitHub employee's laptop.

Attackers claim around 3,800 repos were stolen. GitHub says customer data is safe and has rotated all secrets. Team PCP is selling the code for $95,000, threatening to leak it for free if nobody buys.

The lesson: your security is only as strong as the last extension you installed. Credential masking and sandboxing aren't paranoia — they're survival.

Copilot's Pricing Time Bomb

Starting June 1, GitHub Copilot moves to usage-based billing. The old flat-rate premium request system is dead.

The base price stays the same — $39/month for Pro Plus with $39 of credits included. But here's the catch: credits get consumed based on tokens (input, output, cached), and heavy users are projecting their costs could jump from $40/month to $900/month.

GitHub is also ending annual plans.

The economics are simple: agents cost real compute, and flat-rate pricing was always a subsidy. The era of unlimited AI for a fixed fee is ending — everywhere.

The SpaceX Compute Deal

Anthropic agreed to pay SpaceX $45 billion over three years for computing power. That's $1 billion per month — roughly 5.5% of SpaceX's entire annual revenue.

What does that buy? Access to SpaceX data centers with hundreds of megawatts of power and hundreds of thousands of Nvidia chips.

But Anthropic isn't stopping there. They're in early talks with Microsoft about using custom Maia 200 chips. They already have deep AWS and Google Cloud partnerships. The strategy is clear: don't depend on one supplier, and get as much compute as humanly possible.

When a company is spending $1B/month on compute, you know the AI race isn't slowing down.

Claude Code Updates

A few things shipped this week that matter for developers:

v2.1.150 (May 23) — Internal infrastructure improvements.

v2.1.149 (May 22) — The /usage command now shows a per-category breakdown: skills, subagents, plugins, and per-MCP-server costs. If you've been wondering where your tokens are going, now you know.

v2.1.148 (May 22) — Fixed the Bash tool returning exit code 127 on every command (a regression from v2.1.147).

v2.1.147 (May 21) — Pinned background sessions (Ctrl+T in Claude agents) now stay alive when idle and are restarted in place to apply updates. New /diff scrolling in detail view.

v2.1.145 (May 19) — Added claude agents --json to list live Claude sessions as JSON for scripting.

v2.1.142 (May 14) — New claude agents flags: --add-dir, --settings, --mcp-config, --plugin-dir, --permission-mode, --model, --effort, and --dangerously-skip-permissions.

And the weekly limits increase is still live — 50% more through July 13 for Pro, Max, Team, and Enterprise.

Other Notable Moves

• DeepSeek V4-Pro made its 75% discount permanent. $0.435/M input tokens — 11x cheaper than GPT-5.5 at comparable performance.
• Anthropic acquired Stainless for $300M to enhance API SDK and MCP server integration.
• Gemini CLI dies June 18. Google is replacing it with Antigravity CLI, rebuilt from scratch in Go with multi-agent orchestration.
• OpenAI's Codex can now control your Mac even when the screen is locked — via a new "Locked Use" feature that integrates with macOS security architecture.
• SAP integrated Claude into Joule via MCP, enabling AI agents to handle finance, HR, procurement, and logistics autonomously.
• Claude Managed Agents shipped three new features on May 6: Dreaming, Outcomes, and Multiagent Orchestration.
• Cerebras priced its IPO at $185, popped 68% on debut.

The Takeaway

The AI industry just had its most concentrated week of capital deployment, security failures, and talent reshuffling in history.

Anthropic isn't just catching up to OpenAI — it's lapping them on valuation, on enterprise adoption, and on the raw compute arms race. The Karpathy hire signals something bigger than a talent acquisition: it's Anthropic betting that the next leap comes from AI improving its own training.

Meanwhile, GitHub's breach is a reminder that the tooling layer is the weakest link. And Copilot's pricing shift is the first crack in the flat-rate AI era.

The question isn't whether AI is getting more expensive. It's whether the value scales faster than the bill.

Published May 23, 2026 | Tags: AI, Anthropic, OpenAI, Claude, GitHub, Cybersecurity, Funding Reading time: ~8 minutes

Fog doesn't whisper at the Dead Sea. It swallows.

Saturday morning hung heavy at 430 meters below sea level—the air thick enough to chew, the water a bruised turquoise slab under a grey lid. 21°C and zero visibility. The salt formations didn't gleam; they lurked. White crust against grey nothing. You float there, arms out, and let the density do the work. 34% salinity means you can't sink even if your ego wants to.

That's the mood I chased. Not a postcard. A lungful of wet air.

The Setup

This series is a daily discipline: one Jordanian landmark, rebuilt in miniature, force-fed Amman's real-time weather every morning. No do-overs. The weather dictates the palette, the lighting, the emotional temperature. Rain means mud. Sun means bleached stone. Today meant fog, and fog meant restraint.

I built the foundation in Blender—hard-surface modeling for the salt terraces, simple geometry for the figure. True 30-degree isometric projection. Not the fake 45° "isometric" that games slap on everything. The camera locked. The grid obeyed. Then into Procreate for paint-over: smudging edges, adding grit to the salt crystals, pushing the fog until it felt like cotton balls stuffed into every corner.

FLUX handled the environmental atmosphere—generating base sky and fog density from the live weather feed, which I then beat into submission with manual paint. Think of it as a smart intern who brings the coffee, but you still pick the beans.

Why the Dead Sea?

Jordan doesn't lack icons. Petra gets the glory. Wadi Rum gets the cinematographers. But the Dead Sea is where the land gives up. It's the lowest point on Earth, a body of water that refuses to let you drown. Biblical, sure. But more than that, absurd. Water you can't sink in. Mud people smear on their faces for vanity. Salt that crusts on everything like a bad attitude.

I chose it because it resists prettiness. You can't glamorize fog and salt

May 21, 2026

The AI industry just had one of its wildest weeks. Anthropic is closing in on profitability, Claude Code got a major upgrade, and Google shipped 22 announcements in a single day. Let's break down what actually matters.

Anthropic Nears First Quarterly Profit — $10.9B Q2 Projected

Here's the headline that changes everything: Anthropic expects $10.9 billion in Q2 revenue — more than double its $4.8 billion Q1. That would push the company to an estimated $559 million operating profit.

Let that sink in. Two years ago, Anthropic was burning cash faster than a rocket engine. Now they're on the verge of profitability, driven by one thing: Claude.

Software developers aren't just experimenting anymore. They're deploying. Enterprise teams are running Claude's top-tier Mythos model to hunt vulnerabilities in production code. The demand isn't theoretical — it's revenue.

$1.25 Billion/Month for SpaceX's Colossus

To handle that demand, Anthropic signed a deal that makes your cloud bill look like a rounding error: $1.25 billion per month to rent SpaceX's Colossus data centers. That's 220,000+ NVIDIA GPUs across 300 megawatts of compute.

The deal runs through May 2029. Total value: roughly $45 billion.

Why rent from a competitor? Because building your own data centers takes years. Anthropic needs compute now — and xAI had surplus capacity sitting idle. It's a pragmatic move that prioritizes shipping over ideology.

Claude Code v2.1.146: /simplify Is Now /code-review

For daily Claude Code users, the most actionable update is the slash command rename: /simplify is now /code-review. Same functionality, clearer name, and a new feature — effort levels.

Run /code-review high and Claude digs deeper into your codebase. Run it at default for a quick pass. The depth is yours to dial.

Other fixes in this release:

• Windows PowerShell crash resolved (the pwsh regression from v2.1.118)
• Improved CLAUDE.md context understanding
• Better performance on large repositories

Update with claude update and you're set.

50% More Claude Code — Through July 13

The timing couldn't be better. Anthropic bumped weekly limits 50% for all Pro, Max, Team, and Enterprise users. The promotion runs through July 13, 2026.

What that means in practice:

• Pro ($20/mo): ~40 → 60 hours of Sonnet weekly, 8 → 12 hours of Opus
• Max 5x ($100/mo): ~50 → 75 hours of Opus weekly
• Max 20x ($200/mo): ~200 → 300 hours of Opus weekly

The move is clearly aimed at keeping developers from migrating to Codex. The 50% buffer gives you room to experiment — and if you pair it with smart routing (Sonnet for execution, Opus for architecture), you can stretch even further.

Google I/O: 22 Drops in 24 Hours

Google didn't just compete — they flooded the zone. The I/O 2026 keynote delivered:

• Gemini 3.5 Flash — beats 3.1 Pro on coding benchmarks at half the price
• Gemini Omni Flash — first model combining reasoning with video generation
• Gemini Spark — 24/7 personal agent that runs while your laptop is closed
• Antigravity 2.0 — multi-agent desktop platform for parallel AI work
• Search Agents — agentic AI embedded directly in Google Search
• Gemini for Mac OS — free, available today
• Android XR smart glasses — Samsung + Google collaboration
• CodeMender API — Google's security agent responding to Mythos

The shift is clear: Google is moving from chatbot to agent platform. Gemini Spark running 24/7 while your laptop sleeps? That's not a feature — it's a paradigm.

DeepSeek V4 Enters the Arena

DeepSeek launched V4 with aggressive pricing:

• V4-Flash: $0.28/M output tokens
• V4-Pro: $2.19/M output tokens

They're also building a terminal-native coding agent to challenge Claude Code and Codex directly. The pricing undercut is massive — we're talking 10-50x cheaper than frontier models for comparable performance.

For cost-sensitive teams, this is worth watching closely.

Other Notable Moves

• Anthropic acquired Stainless — the dev tools startup (founded by ex-Stripe engineer Alex Rattray) that makes API wrappers easier
• KPMG deploying Claude to 270,000 employees via Digital Gateway and Blaze
• Claude for Small Business launched — 15 ready-to-run workflows plugging into QuickBooks, HubSpot, Canva, and more
• Anthropic Mythos AI flagged by Cloudflare — the model can chain bugs into exploits, prompting financial regulator briefings
• Nvidia Vera CPU announced targeting the $200B agentic AI market
• Mistral AI acquired Emmi AI — entering physical/industrial AI
• OpenAI won against Musk's lawsuit — jury cleared the path to a potential trillion-dollar valuation

The Takeaway

We're in the infrastructure phase. Anthropic is spending $45B on compute to keep Claude scaling. Google is shipping agent platforms faster than teams can evaluate them. DeepSeek is commoditizing inference. And Claude Code just got 50% more headroom.

For AI engineers, the signal is clear: the tools are maturing, the costs are dropping, and the competition is fierce. Pick your stack, learn the routing strategies, and build.

The window where "using AI" gives you an advantage is closing. The new edge is how you use it.

Follow me on X.com/@yabasha for daily AI engineering insights.

Today's weather in Amman: 🌦️ 16°C — overcast with light rain.

Petra's Treasury (Al-Khazneh) carved into the rose-red Siq canyon, reimagined as a miniature isometric diorama. The Nabataean engineers who built this 2,000 years ago would probably find the cartoon version charming.

This is part of my daily series — one Jordanian landmark per day, rendered in isometric 3D, weather-integrated. Seven cities rotating: Amman, Petra, Aqaba, Wadi Rum, Dead Sea, Jerash, Karak.

Generated with Vertex AI Gemini, weather from wttr.in.

Last month I told you the open-source price war was over. China won. That was the headline.

Tonight I'm telling you something more important: the era of one-size-fits-all AI models is dead.

And that's the best thing that's happened to builders in 2026.

The Leaderboard Nobody Expected

Pull up llm-stats.com right now. The top 20 reads like a battlefield report:

Notice something? The top 7 contains models from 5 different companies across 3 continents. Claude from Anthropic (US), GPT from OpenAI (US), Gemini from Google (US), Kimi from Moonshot AI (China), and DeepSeek from DeepSeek (China).

That's not a ranking. That's a stalemate.

The Three-Way Split

Here's what the benchmarks actually show when you dig past the composite scores:

Reasoning & Intelligence

On the Artificial Analysis Intelligence Index v4.0 — the closest thing to a neutral scoreboard:

• Kimi K2.6: 54 (top open-weight)
• DeepSeek V4 Pro Max: 52
• GLM-5.1: 51

All within 3 points. Statistical noise.

But the moment you slice by task type, the models diverge hard:

• Kimi K2.6 dominates single-shot reasoning. Best agentic score on BenchLM (73.1). SWE-bench Pro at 58.6%.
• DeepSeek V4 Pro Max wins long-horizon agentic work. GDPval-AA: 1554 ELO (highest among open-weight). LiveCodeBench: 93.5%.
• GLM-5.1 owns the independent coding signal. LMArena Code Arena: 1530 Elo (only one of the three with a public, human-preference coding number).

Three models. Three different strengths. Zero overlap.

The MiniMax Wildcard

MiniMax M2.7 dropped last week and it's doing something nobody else is: self-evolution.

This 230B MoE model (10B active) autonomously ran 100 improvement cycles on machine learning competitions. From the official report:

"The ML models trained by M2.7 continuously achieved higher medal rates over time. The best run achieved 9 gold medals, 5 silver medals, and 1 bronze medal."

66.6% medal rate — tying Gemini 3.1 and trailing only Opus 4.6 and GPT-5.4. At $0.30/M tokens.

On SWE-Pro: 56.22%. GDPval-AA: 1495 ELO (highest among open-source). MM Claw: 62.7%, approaching Sonnet 4.6.

MiniMax isn't trying to be the smartest model. It's trying to be the model that makes itself smarter.

Ring-2.6-1T: The Unverified Giant

InclusionAI (Ant Group) dropped Ring-2.6-1T on May 8 under MIT license. 1 trillion parameters, 63B active. The numbers on paper are insane:

• AIME 2026: 95.83 (on par with DeepSeek V4 Pro Max)
• ARC-AGI-V2: 66.18 (beats Gemini 3.1 Pro and Claude Opus 4.7)
• PinchBench: 87.60 (beats GPT-5.4 xHigh)
• ClawEval: 63.82 (beats GPT-5.4 and Gemini 3.1 Pro)

But here's the catch: no neutral third-party verification exists yet. No Artificial Analysis Intelligence Index entry. No independent LiveCodeBench. No independent SWE-bench run.

Vendor-reported benchmarks in 2026 have a track record of melting on contact with independent harnesses. Shortlist Ring-2.6. Don't standardize on it.

The Real Story: Specialization Won

Forget the "which model is best" question. It's the wrong question.

The right question is: which model is best for THIS task?

Here's the cheat sheet I'm actually using:

What This Means For Companies

The implication is seismic:

1. Model lock-in is dead.

When three open-weight models from three different labs are within 3 points on composite intelligence — and each wins on different task types — there's zero reason to commit to a single provider. Mix and match. Route by task.

2. The cost floor dropped to $0.14/M tokens.

DeepSeek V4-Flash at $0.14/M input vs. GPT-5.5's $7.78/M is a 55x gap. For high-volume workloads, that's not a preference — it's a budget decision.

3. Benchmarks now segment by task, not tier.

GPT-5.5 leads Terminal-Bench 2.0 (82.7%). Claude Opus 4.7 leads SWE-bench Verified (87.6%). Gemini 3.1 Pro leads GPQA Diamond (94.3%). Each lab is winning different races. The composite leaderboard is increasingly meaningless.

4. Self-evolution is real.

MiniMax M2.7 proved that a model can autonomously improve itself on ML tasks — and achieve results competitive with frontier closed-source models. This isn't a benchmark trick. It's a paradigm shift in how we think about model capabilities.

5. Trust but verify.

Ring-2.6-1T's vendor numbers suggest it's competitive with GPT-5.5. But without neutral verification, that's a claim, not a measurement. In 2026, the gap between vendor claims and reality has been consistently 5-15 points. Budget accordingly.

The Bottom Line

May 2026 isn't about who's winning. It's about the fact that nobody needs to win anymore.

Open-weight models are within striking distance of closed-source leaders on every major benchmark. The gap has narrowed to 5-15 points on most tasks — and those points can often be closed by fine-tuning on domain-specific data.

The real winners are engineers who stop asking "which model?" and start asking "which model for what?"

The answer is: it depends. And that's exactly how it should be.

Data sources: llm-stats.com, BenchLM.ai, Artificial Analysis, OpenRouter API, vendor model cards. All prices as of May 20, 2026.

Three things happened in the last 72 hours that will reshape how we build with AI. One man moved from OpenAI to Anthropic. One product split the AI brain from the AI hands. And one format war declared a winner.

If you blinked, you missed the week that mattered.

Karpathy Just Changed Sides

Andrej Karpathy — OpenAI co-founder, Tesla's former AI director, the man whose YouTube lectures taught half the field how transformers work — posted seven sentences on X on Tuesday morning.

The first one read: "Personal update: I've joined Anthropic."

He's working on the pre-training team under Nick Joseph. His mandate: build a new group that uses Claude to accelerate the training of the next generation of Claude. He paused Eureka Labs for this. He's not dabbling.

Here's the number that makes this strategic, not sentimental: Anthropic is reportedly closing a funding round at a roughly $900 billion valuation. That would put Anthropic above OpenAI in private markets for the first time.

Karpathy didn't just leave one company for another. He left the company that's losing the valuation race to join the company that's winning it. That's not a career move. That's a bet.

The real play is what he'll build. "Using Claude to accelerate pre-training research" means automating the most expensive, compute-intensive phase of building a frontier model. If Karpathy's team cracks even marginal efficiency gains, Anthropic's training costs drop while everyone else's stay flat. That's the kind of flywheel that compounds.

The Day Anthropic Split the Brain From the Hands

On May 19, from the stage of Code with Claude London, Anthropic announced two features that change the enterprise AI conversation entirely: self-hosted sandboxes (public beta) and MCP tunnels (research preview).

Here's what landed:

Self-hosted sandboxes mean your files never leave your infrastructure. The agent loop — the part that decides what to do next — stays on Anthropic's servers. But the moment the model says "read this file" or "run this command," that execution happens in a container inside your perimeter. Your network policies, your audit logging, your security tools. The file content never transits to Anthropic.

Four managed providers launched day one: Cloudflare (microVMs, millisecond startups), Daytona (SSH-accessible, stateful, pause/resume), Modal (GPU-optimized for AI workloads), and Vercel (VM security with VPC peering). Or bring your own.

MCP tunnels are the sleeper feature. A deployed gateway establishes a single outbound connection to your internal services. No inbound firewall rules. No public endpoints. End-to-end encrypted. Your databases, private APIs, and knowledge bases become agent tools without ever touching the public internet.

The architecture is clean: intelligence on Anthropic, execution on your infra. But here's the caveat nobody's naming — the orchestration layer, the part that actually decides what your agent does, stays on Anthropic's servers. A fully on-premise deployment isn't possible. Your data stays local during tool execution. Your agent's cognitive loop does not.

That's a trade-off worth understanding before you bet a production pipeline on it.

Meanwhile, BerriAI open-sourced the LiteLLM Agent Platform — a Kubernetes-based self-hosted infrastructure for running multiple isolated agent sandboxes with session continuity. And Containarium launched as an MCP-native sandbox that spins up lightweight containers in milliseconds.

The self-hosted agent infrastructure space went from "doesn't exist" to "four options plus open source" in a single week.

HTML Just Killed Markdown

On May 8, Thariq Shihipar — a member of the Claude Code team at Anthropic — posted what became one of the most-discussed dev takes of the quarter:

"HTML is the new markdown. I've stopped writing markdown files for almost everything and switched to using Claude Code to generate HTML for me."

Karpathy retweeted it. The post hit tens of millions of views in 48 hours.

Shihipar's argument was concrete. HTML lets Claude do things markdown simply can't:

• Inline SVG diagrams instead of fenced ASCII art
• Interactive widgets — sliders, toggles, collapsible sections — so a PR review becomes a navigable artifact instead of a wall of text
• In-page navigation, color-coded severity, real layout
• Semantic structure the model can hang richer reasoning on

The rebuttal landed fast. Kurtis Redux pointed out three problems:

1. HTML is 2-4x slower to generate than the markdown equivalent
2. Verbose markup dilutes model attention — longer output means more chances to hallucinate structure
3. Output tokens are the expensive tokens — 3-5x the cost of input across every major API

Recommending 2-4x more output tokens is a real line item on your API bill.

But here's what both sides missed. The debate framed it as binary: rich-but-expensive HTML vs. cheap-but-flat markdown. That framing is wrong.

The real insight came from the three-layer model:

Layer 1: Protocol layer — AI-to-AI communication. CLAUDE.md, AGENTS.md, instruction files. This stays Markdown forever. It's the HTTP of agent systems. Nobody reads it directly.

Layer 2: Interface layer — AI-to-human output. Specification reports, PR interpretations, design explorations. This migrates to HTML. Information density, readability, sharing, interaction.

Layer 3: Tool layer — Disposable custom UIs. AI generates a throwaway HTML interface with sliders and toggles for a specific decision, you interact with it, copy the result back. This layer didn't exist before AI.

Markdown didn't die. It retreated to the protocol layer and became more deeply rooted. HTML took over the interface layer. And the tool layer is genuinely new.

The data backs this up. Cloudflare's "Markdown for Agents" showed HTML-to-Markdown conversion cuts tokens by 80% (16,180 → 3,150 tokens). HtmlRAG from WWW 2025 demonstrated that pruned HTML outperforms Markdown for retrieval accuracy. And Microsoft Research found HTML beats Markdown by 28 points on column retrieval in table QA tasks.

The format war isn't about which is "better." It's about which layer you're building for.

What This Week Actually Means

Karpathy's move signals that the AI talent war has crossed a threshold. When the man who taught the world about transformers leaves OpenAI for Anthropic, it's not about salary or title. It's about where the most important work happens next.

Self-hosted sandboxes mean the enterprise "but where does my data go" objection just lost its strongest argument. The architecture isn't perfect — orchestration stays remote — but for most regulated industries, tool execution staying local is the 80/20 solution.

And the HTML shift? It's the first sign that AI-native development isn't just about better prompts or bigger models. It's about fundamentally different output formats. The terminal is becoming a platform. The document is becoming an application.

The next 90 days will be the most competitive window in AI history. Karpathy is building Claude's brain at a company worth more than OpenAI. Anthropic just gave enterprises a way to run agents on their own infrastructure. And the way AI delivers information to humans changed format.

If you're still writing markdown files for AI output, you're building for the protocol layer. The interface layer has moved on.

Published May 20, 2026 — Covering Anthropic, Karpathy, self-hosted sandboxes, and the HTML vs. markdown shift through May 20, 2026.