Watch the world's largest developer event live

What we cover

• —Coding agents in your IDE: what to delegate, what to keep.
• —Architecture decisions that compound when AI writes code alongside you.
• —Prompt design and context engineering as real engineering disciplines.
• —Retrieval, latency, and shipping software that survives users.
• —Evals and feedback loops you can actually trust against real traffic.
• —Refactoring legacy code with agents — what works, what blows up.

What we cover

• —Multi-agent architectures, MCP, and tool orchestration patterns that hold up.
• —Agent memory, long-running agents, and what breaks after six months in front of users.
• —Guardrails, fallbacks, and the boring plumbing that keeps agents from going sideways.
• —Cost, latency, and throughput trade-offs once agents are on the critical path.
• —Honest post-mortems from teams who shipped agentic systems.

What we cover

• —Rust, Go, modern Java, Kotlin, and TypeScript at scale.
• —WebAssembly moving from edge experiment to mainstream runtime.
• —Architectural calls that compound when AI agents start writing code too.
• —Interop, FFI, and polyglot stacks when no single language wins anymore.
• —Performance tuning, memory models, and concurrency in real production code.

What we cover

• —Internal developer platforms treated as products, with golden paths that people actually use.
• —CI/CD that does not flake, and release flows when AI agents open PRs alongside humans.
• —Self-service infra and paved roads that scale across dozens of teams.
• —Build times, caching, and the small wins that change how engineers feel about your platform.
• —Developer experience as a measurable outcome, not a vibe.

What we cover

• —Capacity planning, multi-region deployment, and observability that answers questions.
• —GPU-heavy workloads next to classic services, and nondeterministic latency on call.
• —SLOs and agent telemetry when half your critical path is a model you do not own.
• —Incident response and on-call in a stack that mixes deterministic and probabilistic systems.
• —Cost, capacity, and the reliability trade-offs of running models in production.

What we cover

• —Pipelines, lakehouses, and streaming systems that hold up under real load.
• —Vector databases sitting next to OLAP, and training-data quality as model quality.
• —Data contracts, lineage, and freshness when AI features depend on the same plumbing as dashboards.
• —Training data, evaluation sets, and the feedback loop between product and pipeline.
• —Analytics engineering between raw events and product decisions.

What we cover

• —Supply-chain security, dependency hygiene, and identity wired into builder workflows.
• —Prompt injection, agent boundaries, and sensitive-data exfiltration in AI features.
• —Authn, authz, and secrets management when agents act on behalf of users.
• —Compliance, audit, and the new evidence you need for AI-powered features.
• —Threat modeling for a dual-use world where defenders and attackers share tools.

What we cover

• —Testing for distributed systems: contract tests, deterministic CI, observability-driven QA.
• —Evals, guardrails, and regression suites for LLM-powered features and agents.
• —Synthetic data and replay traffic for testing nondeterministic systems.
• —Shift-left vs shift-right when half the failures only show up in production.
• —Metrics that actually correlate with users trusting your AI feature.

What we cover

• —Team design, hiring, and training in a world where AI touches most engineering work but only a slice is genuinely delegated.
• —Build vs buy, platform choices, and governance for tools that change every quarter.
• —Budget, headcount, and ROI conversations when half the tooling is changing under you.
• —Leading through ambiguity when neither vendors nor benchmarks have caught up yet.
• —Architectural decisions that compound across the next two years.