R/reports/devEx

Must have

• Python, TypeScript/JavaScript, Go
• Bazel, Buildkite, GitHub Actions, CircleCI, Jenkins
• Docker, Kubernetes
• Terraform, Helm
• Git, GitHub (monorepo workflows)
• Claude Code, Cursor, GitHub Copilot, Codex
• AWS (or GCP), Bash/Unix, Linux

Nice to have

• Rust, C++, Ruby/Rails, Java, Kotlin, Nix/NixOS, Starlark
• Buck, Pants, Gradle, Turborepo, Vite, webpack, esbuild, CMake
• Bazel Remote Execution, BuildBarn, BuildBuddy, remote caching
• Pulumi, ArgoCD, Flux, GitOps, Spinnaker, Argo Rollouts, merge queues
• MCP servers, Devin, vLLM/SGLang/TGI
• Grafana, Datadog, Prometheus, OpenTelemetry, Honeycomb
• Playwright, pytest, k6, Selenium
• Postgres, Snowflake, BigQuery, ClickHouse, Kafka
• gRPC, GraphQL, Protocol Buffers, OpenAPI
• OpenGL, Qt, Unity, Vulkan (visualization roles)

Build systems and CI/CD

• Hermetic builds - dependency-graph correctness, sandboxing, reproducibility, toolchain pinning, affected-target detection; know where cache invalidation and non-determinism break.
• Build acceleration - remote caching, remote execution, cache hit-rate tuning, test sharding/selection, build-time and queue-time profiling.
• CI reliability - flaky-test detection/quarantine, merge queues, retry/bisect automation, hermetic ephemeral environments per PR.
• Monorepo management - branching strategies, large-file handling, code ownership, dependency governance, polyglot toolchain integration.

AI-assisted and agentic development

• Agent-ready codebases - exposing internal systems via API (not UI-only), agents.md/context files, repo conventions legible to agents.
• Harness engineering - tool/permission scoping, state carried forward, retries, checkpoints, guardrails, evals for agent-generated PRs.
• Context engineering - what to send the model, custom instructions, skills libraries, measurable improvement in agent output quality.
• Agent sandboxes - reproducible cloud dev environments where agents run test suites autonomously, secrets/PII guardrails, safe egress.
• AI dev measurement - usage, reliability, cost, cycle-time, % AI-authored PRs; distinguishing real productivity from activity.

Developer experience and internal platforms

• Paved roads - service templates, golden paths, CLIs, codegen, self-serve provisioning, onboarding/setup automation.
• Friction diagnosis - DORA/SPACE metrics, developer interviews, bottleneck identification, toil elimination, adoption strategy.
• Local dev parity - dev/CI parity, hot-reload, containerized local stacks, fast feedback loops.

Release engineering and delivery

• Progressive delivery - canary, blue/green, staged rollouts, automated rollback/roll-forward, deploy-health gates.
• Release safety - regression detection, deploy gates, promotion criteria, blast-radius minimization, signed artifacts/SBOMs/provenance.
• OTA/multi-component releases - versioning, A/B image updates, staged fleet rollout (device/embedded roles).

Testing and quality infrastructure

• Test architecture - test-pyramid judgment, contract/API testing, integration/E2E harnesses, coverage views across teams.
• Test reliability - flake budgets, quarantine, deterministic seeds, hermeticity, root-cause triage.
• HIL/SIL validation - fault injection, regression suites, safety-critical clearance (AV/embedded roles).

Observability and metrics

• Pipeline telemetry - build/CI dashboards, failure-rate and latency tracking, structured logging, traces, alerting hygiene.
• Performance data pipelines - metric capture, variance/significance testing, automated regression detection.

Cloud-native infrastructure

• Container orchestration - Kubernetes at scale, image/package set management, multi-region/multi-cloud.
• Secure delivery - least-privilege access, secrets/credential handling, artifact permissions, supply-chain hardening.

The 20% that covers 80%
Master the build/CI/release core first; it gates nearly every posting regardless of company.

• Bazel (or Buck/Pants/Gradle) plus one CI orchestrator (Buildkite or GitHub Actions)
• Docker + Kubernetes + Terraform
• Python and TypeScript/Go in a large monorepo

The fastest path to "qualified"
The smallest cluster that unlocks the most roles: monorepo build optimization + CI flake reduction + a paved-road CLI/template + measured cycle-time impact. Add hands-on fluency with Claude Code/Cursor and you match both the classic DevEx roles and the new AI-DevX roles.

Table stakes vs differentiators
Expected everywhere: CI/CD, Docker/K8s, Git monorepo, a scripting language, flaky-test handling. Genuine differentiators:

• Agent-ready infrastructure: MCP servers, harness/context engineering, agent sandboxes
• Remote build execution and cache internals (BuildBarn/BuildBuddy/Bazel RE)
• Writing Bazel rules/macros and migrating a codebase onto Bazel

Rising vs fading
Rising and underspplied: AI-DevX (agent enablement, MCP, evals for AI-generated PRs), agent sandboxes, AI-driven CI triage. Steady: build systems, release safety. Fading as a standalone pitch: manual QA/SDET without automation or AI — nearly every SDET posting now requires AI-assisted test generation.

Skills that transfer across the whole set
One investment in build/CI/test infra unlocks DevEx, Developer Productivity, Release Engineering, SDET, and Internal Platform roles. Adding agent enablement on top unlocks the unicorn AI-DevX tier (Ramp, Hightouch, Sentry, Temporal, Anthropic, OpenAI).

Interchangeable vs non-negotiable
Learn one per group: CI orchestrator (Buildkite ≈ GitHub Actions ≈ CircleCI ≈ Jenkins), IaC (Terraform ≈ Pulumi), GitOps (ArgoCD ≈ Flux), monorepo tool (Bazel ≈ Buck ≈ Pants). Non-negotiable across the board: Docker/Kubernetes, Git, Python, and demonstrable AI-coding-tool fluency.

Gaps that create leverage
Frequently required, rarely held well: deep Bazel internals (custom rules, remote execution), MCP server authorship, and rigorous productivity measurement (DORA/SPACE tied to delivered value, not vanity metrics).

Company-stage signals

• Growth (Semgrep, Cursor, Supabase, Replit): breadth, CLI/cross-platform craft, ship-fast ownership
• Unicorn AI-DevX (Ramp, Hightouch, Anthropic, OpenAI, Temporal): agent enablement, monorepo scale, paved roads
• AV/embedded (Zoox, Waymo, Nuro): C++ systems depth, HIL/SIL, safety-critical validation
• Mature/faang-plus (Roblox, Figma, Reddit, Netflix, Google): scale, multi-platform release safety, measurable reliability

Lead with quantified platform impact
The signals that drive the decision are measured improvements to other engineers' velocity. Put numbers on build time, CI flake rate, and engineers served.

• "Cut median CI time from 22m to 6m across a 1,200-target Bazel monorepo"
• "Reduced flaky-test failures 80% via quarantine + auto-bisect for 300 engineers"

The immediate-yes combo
Build/CI ownership + AI-agent enablement with adoption numbers. This matches the largest and best-paid cluster of postings.

• "Built MCP integrations + agents.md context that raised agent-generated PR merge rate; agents now author >50% of merged PRs"

The "wow, that's deep" combo
Remote build execution or a Bazel migration, plus a harness/eval system for AI-generated code. Going one level deeper than peers here turns a line into a standout.

• "Authored custom Bazel rules and stood up remote execution (BuildBarn) cutting cold builds 4x"

Projects eng managers are hoping to find

• Agent dev environment: cloud sandboxes where coding agents run full test suites autonomously, with secrets guardrails — "Shipped reproducible agent sandboxes; agents run the full suite and open repository-aware PRs."
• Progressive delivery system: canary + automated rollback gating multi-region K8s deploys — "Built deploy-health gates and auto-rollback; cut change-failure rate and shipped daily."
• PR-ephemeral test harness: minimal stack spun up per PR with seeded data — "Ephemeral K8s environments per PR running Playwright + API suites against seeded tenants."

What reads junior
Tool-user framing with no scope or outcome.

• Avoid: "Wrote CI pipelines in GitHub Actions and fixed failing tests."

What reads senior/staff
Same work, leveled to ownership, scale, and cross-team outcome.

• "Owned CI/CD for 300+ engineers; defined merge-queue and caching strategy that doubled deploy frequency while lowering change-failure rate."

Red flags that make recruiters pass

• Manual QA with no automation or AI: "Executed manual regression test cases each release" — every SDET posting now wants automation + AI-assisted testing.
• Pure config without engineering: "Maintained Jenkins jobs and updated YAML" — postings explicitly want production software, not tool configuration.
• AI as buzzword: listing "Claude/Cursor" with no built artifact, when roles want harness/context/eval systems that measurably improved output.

Worth flagging
Several roles gate on specifics that belong on the resume verbatim when true: active secret clearance and FedRAMP/STIG (Scale public sector), C++ systems depth with profiling/concurrency (Waymo, Nuro, Zoox), formal methods and DO178/ISO26262 (Zoox safety), and large-React real-user performance work (Notion, Discord, Vercel). These are narrow filters — name the exact standard, framework, or metric.