Loading the page…
Shaping the future of software engineering
AI has transformed how we write code. GitHub Copilot, Cursor, and Claude autocomplete functions, generate boilerplate, and accelerate greenfield development. These tools are impressive—and they've made writing code faster than ever.
But here's the question nobody's asking: has the software we actually use gotten 10x better this year?
The answer is no. And there's a structural reason why.
Code represents roughly a third of what software engineers do. The other two-thirds? That's production—where code gets deployed, runs on infrastructure, generates telemetry, and inevitably creates new failure modes. It's where engineering teams spend most of their time: triaging alerts, investigating incidents, debugging systems, deploying safely, and optimizing costs.
This is where the next frontier in AI lies. Not in generating more code, but in working with the production systems where that code actually runs.
See the agents that run and fix software in action
Join our engineering leads for "Behind the Build", a webinar series deep-dive into how we built agents that run software.
Every business today is a software business. The bank is software. The airline is software. Customer experience is software experience.
AI has collapsed the cost of creating software. Code is cheap. Features are cheap. What's scarce is trust—software that works when customers need it, that doesn't break, that earns confidence through reliability over time.
Distribution follows trust. Trust follows reliability. Reliability is production.
This is why production represents the biggest leverage in software engineering. Not just because engineers spend the majority of their time there—though they do—but because production is what customers actually experience. The elegance of your codebase doesn't matter if your service is down. The sophistication of your architecture doesn't matter if latency is degrading customer experience.
Production is where software engineering meets reality.
Coding AI works because code is self-documenting. Relationships are explicit in imports, calls, and types. Code exists in files you can feed to a model. The context is contained and structured.
Production is different. Production is fragmented systems, siloed expertise, and undocumented knowledge.
The root cause of a 502 error doesn't live in a single file or tool. It lives in relationships between components—how code interacted with infrastructure under specific conditions, how a deployment cascaded through dependent services, how resource constraints manifested as latency spikes. No single tool captures this complete picture.
The people with the knowledge aren't always in the room. Application engineers understand the code. Platform engineers understand the infrastructure. SREs understand the operational patterns. But production problems require connecting dots across all three domains—and that cross-domain expertise is what separates senior engineers from the rest of the team.
The most valuable production knowledge isn't written down. It's pattern recognition that senior engineers carry: knowing which metrics to correlate, which logs to check first, which architectural decisions created which failure modes. This tribal knowledge gets shared through runbooks, Slack threads, and war room discussions—but it never becomes structured, searchable, or scalable.
Production isn't a harder version of the coding problem. It's a different problem entirely.
Building AI that works with production systems requires three capabilities that don't exist in coding assistants:
AI for production needs to understand relationships across code, infrastructure, and telemetry. Not just what's in your GitHub repository, but how those services are deployed, what infrastructure they run on, what metrics they generate, and how changes propagate through dependent systems.
This means connecting to your production environment as-is—no rip-and-replace of your existing stack—and building understanding of how everything interacts. Service dependencies. Infrastructure relationships. How code changes manifest in telemetry. The implicit knowledge that senior engineers carry but that exists nowhere as structured data.
During an incident, senior engineers don't pursue a single hypothesis. They investigate multiple angles in parallel: application-level issues, infrastructure constraints, database performance, network conditions. They gather evidence from logs, metrics, traces, and code—then synthesize findings across domains to identify root cause.
AI for production needs to work the same way. Not single-shot LLM responses that guess at answers, but multi-agent orchestration that formulates hypotheses across domains, gathers evidence from your actual systems, and provides recommendations backed by proof.
This requires operating your tools like an expert—knowing what to query, how to interpret results, and where to look next. Iteratively refining the investigation until finding the actual answer, not just the most plausible one.
Production knowledge accumulates through experience. Senior engineers learn which patterns indicate which problems. They remember how past incidents were resolved. They recognize when current symptoms match previous failure modes.
AI for production needs to capture this same learning. Not by reading documentation after the fact, but by sitting in the execution path—seeing how investigations unfold, what paths work, what corrections engineers make, how problems get resolved. Every incident becomes searchable precedent. Every investigation builds institutional knowledge that gets distributed across the entire team.
We're at an inflection point. AI transformed coding workflows by making individual engineers more productive at writing code. The next transformation is making engineering teams more effective at working with production systems.
This shift changes what becomes possible:
Engineers resolve incidents in minutes instead of hours—not because they're paged faster, but because AI investigates across code, infrastructure, and telemetry to surface root cause with evidence.
Teams optimize infrastructure costs based on actual usage patterns—not through manual analysis of dashboards, but through AI that understands how services consume resources and where waste exists.
Engineers build features on existing systems with full production context—not just generating code in isolation, but understanding current architecture, dependencies, and operational constraints.
New engineers onboard in weeks instead of months—not by reading outdated documentation, but by accessing the distributed expertise that senior engineers carry.
This isn't about automating away engineering work. It's about distributing the cross-domain expertise that only senior engineers have today—giving every engineer on the team the ability to work effectively across production systems.
The teams building the next generation of software won't just write code faster. They'll operate production more effectively.
They'll reduce mean time to resolution not through better alerting, but through AI that autonomously investigates across systems to identify root cause. They'll ship features faster not just through code generation, but through architectural guidance based on actual production context. They'll scale infrastructure more efficiently not through better dashboards, but through AI that analyzes usage patterns and eliminates waste.
The competitive advantage won't be how quickly you generate code. It will be how reliably you operate production, how efficiently you ship, and how effectively you distribute expertise across your team.
Production is where software engineering meets customer experience. It's where reliability is built. It's where trust is earned.
AI for production isn't the next incremental improvement in developer tools. It's the next frontier in software engineering—and it's happening now.
AI for prod ebook
Learn how top engineering teams use AI to run production.
