# Stephane Jourdan, Simon Rohrer & Pini Reznik - From Pipelines to Prompts: Surviving the Shift to AI

## Executive summary

This panel discusses the seismic shift from traditional DevOps and Cloud-native practices to AI-native development. Speakers emphasize that while AI agents offer unprecedented speed in coding and diagnosing production issues (24/7), this acceleration introduces significant risks regarding code quality, system context loss, and maintainability. The consensus is that robust guardrails—such as advanced observability stacks, deterministic linting, and disciplined harness engineering—are more critical than ever to manage the complexity of AI-driven deployments.

## Key takeaways

- AI Shift Magnitude: The move to AI is described as potentially 10x or 100x more dramatic than the Cloud shift, impacting not just development teams but every department in an organization. The speed of change requires organizational-wide adoption of AI tools.
- Production Agents and Context: AI agents are rapidly deploying fixes and features (sometimes 24 hours a day). This necessitates proactive context management, deep observability stacks (e.g., combining Elastic logs with Service Now incident reports), and knowledge of service relationships to manage the 'blast radius' of changes.
- Code Quality Guardrails: The agents write code that is productive but often poor quality. Speakers strongly advise maintaining rigorous basics like linting and determinism, noting that relying solely on LLMs for perfect output is dangerous.
- Continuous Improvement Discipline: The core principle of Continuous Integration/Delivery (CI/CD) must be maintained. Advanced teams are implementing self-reflecting agents that learn from both problems and solutions, treating failure feedback as a mechanism for continuous improvement.

## Technical details

- Harness Engineering: This methodology is crucial for ensuring that when failures occur, the error is fed back into the system to prevent that class of error from happening again. It provides necessary determinism in an increasingly volatile environment.
- Observability Stack: For production agents, a comprehensive observability stack is required to provide the necessary context (e.g., linking Elastic logs with Service Now incident reports) that allows for rapid root cause analysis.
- AI Agents in Production: A new class of 'self-reflecting' agents is emerging, which learn from both the problem and the solution, adding this knowledge to a specific company memory for highly tailored maintenance.
- LLM Limitations: Speakers warn that LLMs are prone to hallucination. Relying on them without deterministic guardrails or explicit context is insufficient, especially at enterprise scale.

## Practical implications

- Elevate the focus from simply automating tasks to managing system context and architectural trade-offs (e.g., cost vs. speed).
- Implement rigorous code quality checks (linting, determinism) as a primary guardrail against LLM output.
- Invest in advanced observability tools that synthesize data across multiple sources (logs, incident reports, service maps) to provide human-understandable trade-off decisions.
- View AI integration not as full automation, but as 'co-driving'—a highly powerful partnership requiring human oversight and disciplined processes.

## Topics

AI-native development, DevOps evolution, LLM code quality, Continuous Integration/Delivery (CI/CD), Observability and Context Management, John Smart's book Sooner Safer Happier, Bagita's article on harness engineering

Source: https://www.youtube.com/watch?v=1grkxo4cyKY