The Video Signal

Channel

AI Native Dev

Digests from AI Native Dev

· 47:39

Patrick Debois Maps the Patterns of AI-Native Dev

Drawing parallels between DevOps and AI evolution, Patrick Debois outlines a new socio-technical map for AI-native development. The shift requires organizations to move beyond simple coding capability by mastering structured patterns (Prompting $ ightarrow$ Context $ ightarrow$ Harness $ ightarrow$ Loop Engineering). Success hinges on building shared platforms, optimizing processes through continuous feedback loops, and shifting organizational focus from measuring token usage to improving contributions to shared components.

Key takeaways

  1. AI Maturity is Continuous Exploration 10:36

    Debois argues there is no single 'maturity' point; the field requires constant adaptation across Prompting, Context, Harness, and Loop Engineering. The goal is continuous learning and adapting processes rather than reaching a fixed state.

  2. The Four Layers of AI Enablement 18:39

    AI adoption must be addressed at four levels: Agent enablement (the technology), Team enablement (shared components/libraries), Platform enablement (centralized tools like registries and evals), and Organization enablement (process change).

  3. Shift Measurement from Usage to Contribution

    Effective measurement for AI adoption should focus on how much people are contributing to shared components and fixing the system, rather than solely measuring token usage or license counts. This metric reflects true organizational improvement.

  4. Hiring System Thinkers Over Coders 43:52

    The most valuable skill in the AI era is being a 'system thinker'—someone who cares about architecture and reliability, not just writing elegant code. Adaptability and open-mindedness are paramount.

Watch on YouTube Full article

· 22:25

The DevOps Godfather on AI's "Dark Factory" Problem

Patrick Debois argues that the industry is approaching a 'dark factory' model of autonomous coding agents, mirroring historical skepticism around Continuous Delivery [0:02:51]. He emphasizes that success hinges not on better prompts or larger models, but on fundamentally restructuring teams and platforms. The developer role shifts from solo coder to agent orchestrator, requiring improvements in system-level engineering practices (e.g., building tooling for the agents) rather than just fixing the code produced by the agent [0:09:49]. Scaling this requires platform teams to centralize reusable components like skill registries and guardrails, moving organizations from a 'solo developer' model to a 'multiplayer system' [0:10:53].

Key takeaways

  1. Shift from Coder to Orchestrator 5:21

    The modern developer role evolves into that of an agent conductor or orchestrator, managing and guiding autonomous agents rather than writing all the code themselves. This requires a focus on system improvement over individual code fixes [0:02:51].

  2. Focus on Systemic Improvement 9:49

    The key mentality shift is to stop fixing the agent's output code and instead improve the underlying system, context, and tooling (harnesses/loops) that guide the agents [0:09:49].

  3. Platform Team Centralization 20:53

    To scale autonomous development, platform teams must own centralized components—such as skill registries, guardrails, and reusable harnesses—to prevent organizational sprawl and ensure consistency across teams [0:10:53].

  4. New Productivity Metrics

    Instead of measuring token spend, focus on two metrics: the number of human touches required for the agent to succeed, and the multiplier effect gained when a single system improvement benefits all users/teams [0:14:50].

Watch on YouTube Full article

· 35:18

Joseph Katsioloudes - Code Security Reinvented: Navigating the era of AI - AI Native DevCon June 26

AI is revolutionizing code security by helping minimize the gap between developers and dedicated security specialists. While AI tools like GitHub Copilot can significantly improve detection and, more critically, the speed of fixing vulnerabilities (the 'fixing problem'), they are not a replacement for human oversight. Responsible adoption requires utilizing structured protocols like Model Context Protocols (MCPs) and implementing agentic workflows within CI/CD pipelines to ensure deterministic, auditable, and context-aware security checks.

Key takeaways

  1. AI's Role in Security Gap Reduction 18:04

    The primary opportunity is using AI to scale scarce security expertise. While traditional static analysis tools (like CodeQL or Semgrep) are excellent for pattern matching, AI excels at modeling complex behavioral and contextual issues that pass standard checks.

  2. AI Limitations: Hallucinations & Non-Determinism 4:00

    The speaker notes that while AI is powerful, it should not be the sole safety net; good security hygiene remains paramount.

  3. Leveraging MCPs and Skills 22:20

    Model Context Protocols (MCPs) allow AI models to access server-side information from trusted sources (e.g., GitHub Security Lab findings), extending the context beyond narrow training data. Combining MCPs with structured 'skills' ensures that automated fixes are auditable, maintainable, and integrated into development processes.

  4. Agentic Workflows for CI/CD 27:00

    Agentic workflows allow security agents to run on a schedule or trigger automatically. They can perform sophisticated tasks, such as running manual security reviews automated by AI (using quantified knowledge from research) and proposing fixes directly within the Pull Request (PR), accelerating the fix rate.

Watch on YouTube Full article

· 28:43

Katie Roberts - Stop Maintaining, Start Evolving: Applying AI-Native Practices to Brownfield Codebas

This talk addresses the challenge of modernizing complex, legacy 'brownfield' codebases—systems that are highly successful but burdened by accumulated technical debt and tribal knowledge. The speaker outlines how to apply AI-Native Engineering practices not for adding new features, but for architectural reclamation. Key strategies include using established patterns like the Strangler Fig Pattern and Branch by Extraction, coupled with structured processes (e.g., creating a 'plan skill') to systematically pay down technical debt while maintaining continuous function.

Key takeaways

  1. AI should be used for paying down technical debt, not adding to it. 17:33

    Autonomous agents deployed without strict guardrails can cause havoc through over-optimization or generating 'dark code,' undermining implicit architectural constraints and creating new hidden technical debt. Safety and bounded scopes are paramount.

  2. Adopt a structured approach to brownfield modernization. 20:05

    Instead of starting with the code, begin by conducting forensic investigations using developer input (eyewitness accounts) and creating objective data visualizations (e.g., value vs. complexity graphs) to identify high-priority areas for improvement.

  3. Prioritize planning over immediate migration. 25:32

    In brownfield environments, the planning phase is critical. Focus on creating a structured roadmap and defining clear contracts (specs) before writing code to ensure the right thing is built.

  4. Use AI-assisted skills for process automation. 26:30

    Implement multi-agent flows ('skills') that automate tasks like generating PRDs from documentation, creating Jira tickets, and performing detailed code mapping. This accelerates development cycles (e.g., reducing 6 months of work to 8 weeks).

Watch on YouTube Full article

· 32:04

Justin Cormack - When Tests Lie: Using Observability to Keep AI Honest - AI Native DevCon June 2026

The talk explores the challenges of using AI to build large-scale, complex distributed systems, exemplified by building an AWS S3 compatible object storage system in Rust. While testing is crucial, relying solely on achieving 100% test coverage is insufficient for complex systems. The speaker emphasizes that observability, robust test articles (like external services), and a 'human-in-the-loop' approach are necessary to enforce correctness, discover edge cases, and manage issues like race conditions and flaky tests in AI-assisted development.

Key takeaways

  1. Observability is Critical for Large Systems 17:47

    For complex distributed systems, the public API often doesn't cover all background behaviors. Observability techniques (like tracing) are necessary to infer or observe invisible behaviors that standard APIs cannot expose.

  2. Test Articles Provide Grounding 21:00

    Using an existing system, such as AWS S3, as a 'test article' provides a crucial behavioral baseline. This is more valuable than relying on documentation, which may be inaccurate.

  3. Beyond 100% Test Coverage 13:44

    Achieving 100% test coverage can lead to writing trivial or unhelpful tests. The focus should instead be on expanding the scope of testing and thinking like a QA professional to find edge cases.

  4. Flaky Tests Must Be Fixed 22:00

    The speaker asserts that flaky tests must be fixed immediately, as AI models may incorrectly suggest ignoring them based on training data. Running repeated test suites helps identify these issues.

Watch on YouTube Full article