Topics

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.