The Engineer

The Pragmatic Engineer's survey of 906 engineers (median 11-15 years experience) is the most comprehensive snapshot of AI coding tool usage in production. The headline: Claude Code went from zero to #1 AI coding tool in 8 months, and 56% of respondents do 70%+ of their work with AI. But the nuance matters more than the headline.

Why Terminal-First Won

Claude Code's dominance isn't primarily a UX story — it's a model quality story. Anthropic's Opus 4.5 and Sonnet 4.5 are mentioned more than all other models combined for coding tasks. Even engineers using Cursor or OpenCode route to Anthropic models for actual coding work. The terminal-first architecture compounds this advantage: full filesystem and shell access maps to how Staff+ engineers actually work (across repos, tools, and contexts), which explains the 63.5% adoption rate among Staff+ vs. 49.7% for regular engineers.

The Enterprise Procurement Gap Is a Real Productivity Tax

At small companies, Claude Code usage is at 75%. At 10K+ employee companies, GitHub Copilot leads at 56% — not because engineers prefer it (only 9% love it, the lowest satisfaction of any major tool), but because it's what procurement approved. This creates a measurable productivity gap that compounds daily. The fix isn't faster procurement for one tool — it's a fundamentally different model: per-engineer AI budgets with lightweight security review.

The Multi-Tool Reality

70% of engineers use 2-4 AI tools simultaneously. This isn't indecision — it's rational specialization. Agents for greenfield and debugging, inline completion for flow-state coding, chatbots for design exploration. Meanwhile, Sonnet 4.6 now scores 79.6% on agentic coding benchmarks vs. Opus's 80.8% at 40% lower cost ($3/$15 vs $5/$25 per million tokens), with a 1M token context window. The architecture pattern: Sonnet as your L1 cache, Opus as L2. Try cheap first, escalate on failure.

The Security Counter-Signal

Veracode found AI-generated code introduces security flaws in 45% of tests, and a Stanford study adds that developers using AI assistants write less secure code while being more confident it's safe. This is a systemic risk that scales with adoption. Your CI pipeline needs AI-specific SAST rules targeting common AI failure modes: injection, missing validation, insecure defaults.

The question isn't whether your team uses AI — it's whether they're using the right tools with the right guardrails. The 8-month Claude Code takeover proves the market can shift that fast, and the 45% security flaw rate proves the guardrails aren't optional.

MFA Bypass Is Now a Commodity Service

Starkiller isn't a proof-of-concept — it's a commercial phishing-as-a-service platform selling AitM reverse proxy capability to anyone with crypto. The technique: a reverse proxy serves the real login page from the real identity provider. The user sees the correct UI, enters credentials, completes MFA, and the proxy captures the authenticated session cookie. TOTP, SMS, and push-notification MFA are all defeated. This has been possible for years (Evilginx, Modlishka), but Starkiller's commercialization drops the barrier to zero.

The only defense: FIDO2/WebAuthn/passkeys, where the credential is cryptographically bound to the origin. A proxy on a different domain simply can't complete the handshake. Start with admin panels and CI/CD systems.

OAuth Redirect Abuse Is Protocol-Level

Microsoft's research describes attackers registering OAuth applications with intentionally invalid scopes. Per RFC 6749, the authorization server redirects to the client's registered redirect_uri with an error parameter — and the attacker's redirect_uri points to their infrastructure. The victim sees a re-authentication prompt (SSO bypassed), and the attacker serves a malicious payload. No tokens are stolen — the OAuth flow is the delivery mechanism, not the target.

This is an abuse of the protocol's designed error handling, not a bug in any specific implementation. If you're an OAuth provider: verify that invalid scope requests result in a user-visible error page you control, not a redirect to the client's redirect_uri.

Wi-Fi Client Isolation Is Theater

UC Riverside tested routers from Netgear, TP-Link, ASUS, Ubiquiti, Cisco, DD-WRT, and OpenWrt. Every single one was vulnerable to AirSnitch MitM attacks. Three root causes: shared Group Temporal Key for broadcast frames, isolation enforced at MAC or IP layer but not both, and weak client identity synchronization. Attackers can steal uplink RADIUS packets and set up rogue RADIUS servers.

If your network architecture documentation lists 'AP client isolation' as a security control anywhere, update it today — that control is theater.

Sub-30-Minute Lateral Movement Makes Manual IR Obsolete

CrowdStrike confirms adversary dwell time is now under 30 minutes. That's not enough time for a human to receive an alert, triage, decide, and execute containment. Your IR architecture needs to look like your CI/CD pipeline: automated, pre-approved, and triggered by signals. Network microsegmentation with auto-isolation, credential rotation on lateral movement indicators, and workload quarantine without on-call approval.

The Release Model Change Is Bigger Than It Sounds

Node.js is moving to one major release per year, every release LTS — no more odd/even dance. The upside is massive for enterprises: every major is LTS, your CI matrix shrinks, and there's no more 'we accidentally deployed on an unsupported odd release.' The downside: the 'fast lane' for bleeding-edge V8 features (remember structuredClone being Current-only for months?) may narrow or disappear.

This isn't formal yet — it's a preview post — but the direction is clear. Update your internal Node.js version policy now so you're not caught flat-footed when it lands.

The TOCTOU Vulnerability Node.js Won't Fix

A race condition in ClientRequest.path allows mutation after construction but before serialization. CRLF validation happens at construction time, so injecting \r\n after that point bypasses it entirely — enabling header injection, body injection, and full HTTP request splitting. The original fix attempt was CVE-2018-12116 in 2018, but a design gap persists.

The critical detail: Node.js has explicitly declared this out of scope for their threat model. Every HTTP client library built on Node.js — libraries with 160M+ combined weekly downloads (axios, got, node-fetch, undici wrappers) — is independently responsible for mitigating a platform-level race condition. If you run Node.js services that proxy HTTP requests, audit whether your request construction patterns allow path mutation between creation and send.

Bun's Browser Target and the Broader JS Ecosystem

Bun v1.3.10's --compile --target=browser produces self-contained HTML files with all JS, CSS, and assets inlined. No other runtime does this. Use cases: internal dashboards, offline tools, kiosk apps. The same release ships TC39 stage 3 ES decorators — with both Bun and TypeScript supporting them, the decorator story is stable enough to build on.

Other ecosystem signals worth tracking: Deno 2.7 stabilizes Temporal API (plan your moment.js migration), the Navigation API hit Baseline across all browsers, and the React Foundation officially launched (governance, not code — reduces Meta bus-factor risk).

The Drizzle ORM joining PlanetScale deserves monitoring if you use Drizzle with Postgres. PlanetScale is a MySQL/Vitess company. The question is whether their incentives tilt Drizzle's roadmap toward MySQL-first development. Don't panic-migrate, but have Kysely or Prisma as contingency.

Agoda's Two-Tier Data Contracts Are the Pattern to Steal

Agoda consolidated three teams' independent financial data pipelines into a single Spark-based pipeline (FINUDP), cutting runtime from 5 hours to 30 minutes through query tuning, partitioning strategy, and DAG restructuring. But the real engineering gold is their operational envelope.

Detection contracts monitor production data and alert when something looks wrong — you can implement these unilaterally. Preventative contracts integrate into upstream producers' CI pipelines and block deployments that would break your data expectations. Running both simultaneously is pragmatic: detection catches what preventative misses, and preventative prevents incidents that detection can only alert on after the fact.

Their shadow testing approach — running old and new pipeline versions against production data and surfacing diffs in code reviews — is genuinely excellent practice that most data teams skip. Unit testing with synthetic data catches maybe 20% of real-world bugs. The other 80% are edge cases in actual data distributions.

The Honest Trade-Offs

95.6% uptime on a financial data pipeline is roughly 16 days of downtime per year. Their 99.5% target is more reasonable but still below expectations for financial infrastructure. The centralization trade-off they acknowledge — any change requires full pipeline testing, slowing development velocity — is the classic monolith problem applied to data pipelines.

The Parquet Sort-for-Compression Trap

A common pattern many data teams cargo-cult: sort data before writing Parquet to maximize RLE compression. RLE accounts for 70-80% of Parquet's compression, but requires sorted data — and sorting requires a full shuffle in Spark (network I/O, disk spills, significant executor time). The smarter play for many workloads: skip the sort, use zstd compression on unsorted data, and accept slightly larger files. zstd handles unsorted repeated patterns via backreferences and gets surprisingly close to sorted RLE at a fraction of the compute cost.

Also watch for dictionary encoding silent fallback: when column cardinality exceeds the 1MB page size threshold, Parquet switches to plain encoding with no warning. Track file sizes normalized by row count to detect this drift.

If your Spark pipeline is running longer than your SLA, the answer is almost always optimization of the existing pipeline, not a technology migration. Spark has enough knobs that a 10x improvement is achievable through tuning alone.