▶ YouTube Summaries

• https://www.youtube.com/watch?v=5wks1W-auKY
• Original title: Slow down to speed up: AI and software engineering

Gergely Orosz (The Pragmatic Engineer) gives a conference talk on how AI has reshaped software engineering over the past six months: a self-inflicted security meltdown at Meta driven by "token maxing" and layoffs, a tour of how Anthropic, OpenAI, Cursor, Google and Uber actually use AI internally, industry-wide trends (team-level agentic systems, AI budget shock, falling software quality, burnout of the engineers who still review code), and closing advice on how individuals and engineering leaders should adapt.

Meta's self-inflicted crisis

Meta/Instagram had its worst week ever. A trivially exploitable bug let anyone take over any Instagram account: fake your location via VPN, then ask Meta AI to send a password-reset verification code to an email you control — no second factor, no real check. The code that caused it was AI-written and AI-reviewed, not touched by humans. The next day Meta's CISO resigned mid-investigation.

Orosz traces the root causes:

• Token maxing: engineers were implicitly (and at some firms explicitly) evaluated on AI token usage, so they inflated usage by using AI for everything, including trivial tasks, to look productive and protect bonuses/job security. Meta had leaderboards with tiers like "immortal," "token," and "legend" before killing the program in April.
• Layoffs: Meta cut ~10% of staff (8,000 people) on 20 May, but pre-announced the cuts a month earlier, so anxious staff burned even more tokens to look busy/valuable instead of focusing on real work — including the trust-and-safety team.
• Forced reassignment ("AI psychosis"): 40% of Instagram's ~7-8 year veteran trust-and-safety org (mostly London-based, ~100 people) was reassigned with days' notice to manual AI data-labeling under Alexander Wang's org. Some teams are now under half their former size and have no on-call coverage. This is described as directed from the top (Zuckerberg/Wang): prioritizing building a state-of-the-art model over business risk.
• Morale is worse than the 2022-2023 layoffs; engineers feel treated as replaceable rather than "royalty" as before; some are logging AI chat prompts in Polish so colleagues can't casually read them (Meta made prompts behind commits public via "trajectories" in December, which backfired).

How top companies actually use AI internally

• Anthropic: Boris Cherny (Claude Code creator) runs 5 parallel agents, ships 20-30 PRs/day. PRDs are being replaced by prototypes. ~100% of Claude Code is written by Claude Code; company-wide adoption is 70-90%. Claude Co-work was built in 10 days and is a major revenue driver — Microsoft reportedly still hasn't shipped an equivalent after ~2.5 months of trying.
• OpenAI: an internal "fix it" button turns a bug screenshot into a Codex PR that even non-engineers can merge; AI code review is tiered (some paths ship with AI-only review, critical paths still need humans). Multiple agents running per engineer is normal (one interviewee said "I had five" agents running during his interview). Codex tests and improves itself overnight and proposes changes each morning.
• Cursor: fully agent-centric as of January; built its own coding model (Composer), runs tens of thousands of GPUs and is moving from pure inference into training, effectively becoming a mini AI lab.
• Google: deeply custom internal stack (Cider IDE, Critique code review, Piper monorepo, Code Search, Borg, Monarch) with Gemini integrated throughout, but adoption lags because Gemini isn't as strong as Opus/GPT, and engineers can only access Claude Code indirectly through Gemini's wrapper.
• Meta: building Metamate; "trajectories" expose the literal prompts behind commits publicly inside the company.
• Uber (~3,000 engineers, ~20 person AI/dev-experience team): built an extensive in-house AI platform — MCP gateway, Agent Builder/Studio (used by 20,000 non-engineers), an internal CLI coding agent, "Minions" (background agents that suggest better/cheaper/faster prompts), an AI-review-focused "code inbox" with SLA-based smart assignment, and automated risk-profiling of risky changes. Other large companies (Stripe, Ramp, Shopify, Airbnb) have similar bespoke internal AI tooling; traditional enterprises (Cisco, JPMorgan Chase) are also rolling out AI at scale, just with smaller platform teams.

Cross-industry trends

• Individual vs. team-level AI (via Laura Tacho, AWS): companies that only apply AI to individual productivity (email, chat, code gen) plateau; the ones pulling ahead start from a business outcome (ship faster, more features at same quality) and build team-level agentic systems that reduce handoffs — this requires real investment, not just buying a vendor tool. Spotify explicitly refuses to trade quality for output and is deliberately slowing AI rollout.
• Token maxing / tool addiction: pricing tiers (e.g., $10 → $20 → $100/$200 plans) create gambling-like escalation; people feel pressure to "use their allowance," don't sleep well, and default into API pricing once they blow through plan limits.
• Middle-management flattening: managers are being laid off or pushed back to individual-contributor/hands-on roles. Orosz argues good middle management (technical, attentive, culture-improving) is being lost, and that this will measurably hurt engineering culture over time. Meanwhile CEOs/CTOs (e.g., Vercel's Guillermo Rauch) are personally vibe-coding again.
• AI budget shock: Sam Altman publicly noted AI budgets have become a sudden pain point. Anthropic turned on API-rate enterprise pricing; GitHub Copilot did the same on 1 June, and companies are blowing through what used to be a month's budget in days. Uber burned its whole year's AI budget by March and now caps spend at $1,500/engineer/month, falling back to free models after that.
• Falling quality / "everything is broken": claude.ai had a month-long input-losing UI bug the PM brushed off; OpenAI's "Agent Builder" (built in 6 weeks by one engineer with Codex) has unresolved P0 bugs 3 months post-launch; an AWS engineer let an internal AI coding tool (Cairo) delete/recreate an environment, causing a major outage — AWS now requires senior-engineer review of AI-generated changes; GitHub's uptime has degraded to well under "one nine," attributed (unconvincingly, per Orosz) to a 3x traffic increase. Dax (Open Code founder) admits his own team ships more hacks than well-designed systems and is deliberately using less AI to preserve quality — and is winning by being more careful, not faster.
• Burnout of engineers who still review: most AI-generated PRs get a reflexive "LGTM"; the minority who actually review, catch bugs, and push back are overwhelmed, under-rewarded at review time, and quitting — Open Code is hiring several of them.
• Trust vs. code volume: Kent Beck's framing — "we're accumulating code faster than we accumulate trust." AI most amplifies engineers who already have judgment/experience; junior engineers can prompt something that runs but isn't maintainable. Old, previously unfashionable patterns (domain-driven design, verbose guardrails/boring enterprise patterns) are coming back because they keep agents ("the new junior engineers") in check.

Advice

For individual engineers:

• Cap daily agent usage to what you can actually review or verify (verification can substitute for full code reading if you build real verification systems, per OpenClaw's Peter Steinberger).
• Tech debt is now cheap to remove — deliberately spend agent time removing it; not doing so means you're using AI inefficiently.
• Experiment with your own agent-usage style; there's no universal best practice (examples ranged from 5 parallel agents to HashiCorp's Mitchell Hashimoto running just one agent at a time).
• Don't outsource learning — if the agent fixes the bug but you don't understand why, your mental model doesn't improve even though the code does.
• The job market is roughly okay globally; top companies are hiring more. US/UK software engineering roles are up ~20% (not AI-specific); Germany/France down 10-13%; Canada flat (2-year data via Indeed). AI engineering specifically (RAG, evals, LLM systems) is now ~10% of software engineering roles and growing — build hands-on AI-engineering skill and side projects to stay marketable, and invest in product/domain understanding (become the engineer who's actually talked to the farmers/mechanics/domain experts your company serves).

For engineering leaders:

• Stay or become hands-on again — use AI to help you personally contribute; leaders are showing up among top committers at some companies.
• Expect to do less people management as orgs flatten; help integrate AI at the systems level to remove friction across teams.

Closing note: the pace of change in software engineering hasn't been this fast since the 1960s. Feeling overwhelmed is normal — periodically stop, ask how to make your own workflow more sustainable and higher-quality, and iterate.