The Video Signal

Channel

AI Native Dev

Digests from AI Native Dev

· 14:35

We Scored Oracle's Database Skill Live: 95% Isn't Enough

The video demonstrates how Oracle's database team utilized AI 'skills'—encapsulated in a repository like `oracle/skills`—to guide AI agents in writing secure and best-practice compliant SQL. The process involved running an automated review (using Tessl) on a skill designed to improve database code generation, which initially scored 95%. Through iterative refinement and applying changes via a 'run, review, fix' cycle, the skill was successfully upgraded to a 100% success rate, showcasing a robust mechanism for encoding complex domain knowledge into AI workflows.

Key takeaways

  1. Purpose of Database Skills 5:51

    The primary function of the skill is to help agents write better SQL and database code by making them knowledgeable about the database's capabilities (e.g., property graphs, vector data). It helps discover what the database can do, rather than relying solely on general agent knowledge.

  2. Skill Review Process 13:44

    The skill was subjected to an automated review comparing it against best practices. The process involves running a 'run, review, fix' cycle, which applies changes and re-runs the validation in an agile style approach.

  3. Achieving 100% Compliance 14:35

    After making specific developer-suggested changes (e.g., adding a recommended sequence task), the skill's review score reached 100%, demonstrating continuous improvement and validation of domain knowledge.

Watch on YouTube Full article

· 33:28

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

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

  1. AI Shift Magnitude 5:25

    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.

  2. Production Agents and Context 8:30

    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.

  3. Code Quality Guardrails 13:40

    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.

  4. Continuous Improvement Discipline 22:50

    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.

Watch on YouTube Full article

· 58:39

Inside the Dark Factory: AI That Ships Code Solo

The video details Tessl's 'Dark Factory,' an autonomous system that handles a significant portion of their code shipping (65-70% of PRs). This factory uses AI agents and sophisticated verification layers to process tickets from inception (Linear) through to merge. The core architectural shift involves moving engineering focus from writing code to designing robust, automated workflows, emphasizing context management and layered verification to build trust in autonomous systems.

Key takeaways

  1. High Automation Rate 2:24

    Tessl routes 65-70% of its PRs through the Dark Factory. Historically, up to 95% of their codebase has never been reviewed by a human.

  2. Shift in Engineering Focus 17:12

    The role of the engineer shifts from implementing tickets to designing complex workflows, scoping tasks for agents, and encoding organizational 'taste' into verification layers (e.g., whiteboarding conversations).

  3. Trust is Earned, Not Enabled 31:00

    Building trust in the Dark Factory requires continuous effort, including running into failure modes and improving verification layers. Accountability remains with the person who filed the original ticket.

  4. Verification Layers are Key 22:22

    The most critical component is not the coding agent itself, but the layered verification system (Verifiers) that allow engineers to encode fuzzy principles (e.g., 'library should be the single source of truth') into deterministic checks.

Watch on YouTube Full article

· 53:34

Harness Engineering: Building an AI Software Factory

Harness engineering is a discipline focused on building automated loops of checks and maintenance agents that allow teams to delegate increasing amounts of codebase development to AI. The goal is not merely higher velocity, but achieving higher quality by shifting from manual code review (the primary bottleneck) to systematic process oversight. This involves tracking three key dimensions—autonomy, automation, and quality—and implementing layered validation systems: the Inner Loop (unit tests/linters), Outer Loop (agentic QA/UI testing), and Meta Loop (maintenance agents that analyze historical data for systemic improvements).

Key takeaways

  1. The Three Dimensions of Agent Adoption 10:39

    When adopting AI agents, track three metrics: Autonomy (how many human course corrections are needed); Automation (the level of oversight required, indicating trust); and Quality (ensuring the shipped product remains high quality). Progressing requires improving these dimensions sequentially.

  2. The Three Loops of Harness Engineering 19:04

    1. Inner Loop (Autonomy): Focuses on cheap, frequent checks like pedantic linting or unit tests to ensure agents get it right the first time. 2. Outer Loop (Automation): Involves slower, in-depth checks, such as agentic code review or running the product through a UI/CLI. 3. Meta Loop: Utilizes maintenance agents that analyze historical data (CI logs, PR comments) to propose systemic fixes and improvements to the entire process.

  3. The Primary Barrier is Organizational 28:20

    Harness engineering is fundamentally an organizational transformation, not just a technical one. Success requires changing workflows—for example, moving from monolithic PRs to smaller, low-risk chunks that can auto-merge, thereby shifting human behavior toward better practices.

Watch on YouTube Full article

· 26:42

Tammuz Dubnov - When Our PM Started Writing Code: What Merge Rate Taught Us About AI Adoption - AI N

The shift toward 'AI native' organizations means that the primary bottleneck is no longer code generation speed but organizational alignment and handoff efficiency. The speaker argues that empowering non-technical decision-makers (PMs, Designers) with agentic tools allows them to execute work directly, collapsing gaps that previously required multiple sprints or lengthy coordination. Success in this transition is measured by the 'merge rate'—the percentage of Pull Requests (PRs) opened by non-technical users that successfully land in production.

Key takeaways

  1. Redefining AI Native 2:00

    AI native means that the person who cares about a feature has the authority and ability to execute the work, collapsing the traditional handover gap between PMs/Designers and Developers. The bottleneck shifts from coding speed to decision-making capacity.

  2. The Importance of Merge Rate 6:00

    Merge rate (the percentage of PRs that land in production) is the key metric for measuring if an organization is successfully adapting to AI-driven workflows. A high merge rate indicates trust and quality between non-technical contributions and the dev team.

  3. The Role of Guards and Architecture 11:20

    As organizations move fast, it is critical not to abandon engineering principles or 'guards' (like testing, architectural standards). The agent must be designed to learn the codebase deeply and maintain these constraints.

  4. Measuring Non-Technical Contributions 14:20

    To measure impact, track: 1) Count of PRs opened by non-technical individuals. 2) Merge rate (e.g., an average merge rate of 74% was cited). 3) Percentage of merged PRs that require zero developer intervention.

Watch on YouTube Full article

· 32:05

Dave Farley - Vibe Coding - Is this really the best we can do? - AI Native DevCon June 2026

The talk argues that while AI represents a massive paradigm shift in software development, relying solely on natural language or current agentic coding practices is insufficient for building complex systems. The core message is that the industry must evolve from being 'solution-focused' to 'specification-focused.' Future programming requires defining desired behaviors using precise Domain Specific Languages (DSLs) and executable specifications (like BDD), ensuring verification at every incremental step.

Key takeaways

  1. The Limitations of Natural Language 12:10

    Natural language is inherently vague, open to misinterpretation, and lacks the simple, consistent grammar required for precise machine execution. It cannot reliably define goals or guarantee deterministic results, making it unsuitable as a primary development tool.

  2. The Role of Specification over Solution 17:25

    Programming languages should be viewed not just as tools to encode algorithms (the solution), but primarily as mechanisms to organize and communicate a precise description of the problem itself. The future program must be an executable specification of what is desired, rather than merely the code that achieves it.

  3. The Necessity of Incremental Verification 23:55

    To manage the speed and scale of AI-generated code (e.g., 12,000 lines/day), development must maintain its core engineering principles: working incrementally, treating changes as experiments, and rigorously verifying every step using continuous delivery practices.

Watch on YouTube Full article

· 33:15

Oleg Šelajev - You're absolutely right, it was your home directory! - AI Native DevCon June 2026

The session addresses the security risks posed by autonomous AI agents running locally, noting that these agents can pose significant threats by accessing sensitive data and executing arbitrary code. To mitigate this risk, Docker introduces sandboxing using MicroVMs—a hardware-level isolation primitive superior to traditional containers. This approach allows developers to run powerful AI agents in a restricted environment with controlled access to the filesystem, network, and secrets, enabling high productivity without sacrificing security.

Key takeaways

  1. The Danger of Autonomous Agents 2:00

    AI agents are highly autonomous and persistent; if given sufficient access (data, external communication, internet), they can execute malicious actions like stealing SSH keys or cloud credentials, leading to massive security incidents. The stakes are asymmetric: the attacker only needs to succeed once.

  2. MicroVMs for Hard Isolation 6:00

    Traditional containers share a kernel and are insufficient for high-stakes AI agent sandboxing due to potential container escaping exploits. Docker's solution uses MicroVMs, providing hardware-level isolation that significantly raises the security boundary.

  3. The Role of Kits (YAML) 10:00

    To improve developer experience in isolated environments, 'Kits' are introduced. These declarative YAML files define reusable configurations for a sandbox, specifying required commands, tools (e.g., programming language toolchains), file placements, and network rules.

  4. Controlled Access Mechanisms 8:00

    Sandboxes implement critical controls including networking proxies (to block specific domains/services) and secrets injection mechanisms, allowing agents to function without direct access to the host machine's private data.

Watch on YouTube Full article

· 37:07

Why AI Agents Need a Data Harness, Not Just a Lakehouse

The talk outlines the necessity of a 'data harness'—a modern data foundation optimized for conversational-pace querying by AI agents. Traditional data pipelines built for minutes-to-hours turnaround fail under this rapid load, leading to errors and wasted tokens. The solution requires combining an open lakehouse architecture (using standards like Apache Iceberg and Apache Arrow) with a robust semantic layer, advanced caching (like Columnar Cloud Cache/C3), and federation capabilities to ensure data is accessible, understandable, and performant for AI use cases.

Key takeaways

  1. AI Agents Require Subsecond Performance 6:32

    Conversational analytics moves at a conversational pace. Legacy systems designed for minutes-to-hours turnaround cannot support this speed; subsecond response time is a critical requirement for agentic workflows.

  2. Three Pillars of AI-Ready Data Foundation 9:32

    Any modern data foundation must be accessible (seeing the whole estate), understandable (having clear, standardized definitions via a semantic layer), and performant (querying data where it lives without moving or cleaning it).

  3. Open Standards Prevent Vendor Lock-in 24:12

    The use of open standards like Apache Iceberg, Apache Arrow, and Apache Polaris ensures that the data platform remains vendor-neutral. This allows users to build performance without sacrificing portability.

Watch on YouTube Full article

· 31:44

Brian Douglas - The beginners guide to training AI on your own code - AI Native DevCon June 2026

This talk outlines a closed-loop system for training AI agents using proprietary code execution traces. The core concept involves capturing every agent interaction (telemetry) via an open-source proxy (tapes.dev), structuring this data into a content-addressable Merkle DAG. This raw trace data is then processed by streaming tools like Kafka and Flink SQL to detect anomalies, which feeds back into the agent's next run—creating a 'self-healing loop.' The captured traces are used for supervised fine-tuning (SFT) or Direct Preference Optimization (DPO) to embed learned skills directly into local models, eliminating reliance on external training data.

Key takeaways

  1. Closed-Loop Agent Training 3:50

    Agents generate data by running in an environment; this telemetry is captured and used immediately for model improvement. This creates a self-healing infrastructure loop, allowing agents to learn from failures (anomalies) and successes.

  2. Data Capture Infrastructure 10:30

    The open-source proxy, tapes.dev, intercepts LLM API calls to build a content-addressable Merkle DAG of every conversation turn, requiring zero instrumentation.

  3. Anomaly Detection and Feedback 2:00

    Streaming pipelines (Kafka/Flink SQL) run continuous anomaly detection on session data (e.g., stuck loops, token spikes). Alerts generated by Flink are read by the agent before its next execution, enabling self-correction.

  4. Knowledge Transfer Methods 22:00

    Captured traces can be used for Specialized Fine-Tuning (SFT) or Direct Preference Optimization (DPO). SFT embeds skills into the model, while DPO uses preference data derived from successful vs. failed sessions.

Watch on YouTube Full article

· 32:16

BONUS EPISODE: 76 Malicious AI Skills Were Hiding in Plain Sight

The security landscape for AI coding agents is rapidly evolving, shifting focus from traditional code vulnerabilities to risks introduced by 'Skills' and context management. The presentation details findings from Snyk’s ToxicSkills research, which uncovered 76 malicious skills containing malware or prompt injection vectors in open agent repositories. To mitigate these threats, organizations must adopt secure-by-default practices, implement governance through private skill registries (like Tessl), and utilize advanced scanning tools that analyze natural language context alongside code.

Key takeaways

  1. The Shift to Agent Security 6:38

    AI agents are changing developer workflows from reviewing lines of code to managing a 'team of agents.' This necessitates securing the inputs (context) and artifacts produced by these agents, making agent security paramount.

  2. Malicious Skills Threat 17:55

    Research found that third-party skills can contain purely malicious code or prompt injection attacks. These threats are difficult for traditional scanners to detect because they operate by influencing the agent's context rather than just being visible malware.

  3. Governance and Scanning Solutions 23:58

    Implementing secure skill registries (e.g., Tessl) that integrate security scanning (Snyk) is crucial. This allows organizations to scan skills for potential prompt injection, malware, and versioning issues before deployment.

  4. Secure-by-Default Stack 27:50

    Best practices include scanning third-party skills *before* use and running security scanners on custom-authored skills to identify potential vulnerabilities, such as mishandling or passing secrets in plaintext.

Watch on YouTube Full article

· 31:25

Robert Overweg - One Brain, No Filtering - AI Native DevCon June 2026

The presentation details a 'One Brain' concept—a centralized, AI-native knowledge management layer designed to eliminate information silos and improve decision-making by weaving together research, client context, and operational data. The system uses an orchestrator (OpenClaw) and structured vaults to allow agents to access and synthesize organizational knowledge in real time, shifting focus from manual file retrieval to idea generation and proactive insights.

Key takeaways

  1. Shift from File Search to Idea Synthesis 5:40

    The core value lies in moving beyond searching for specific files; the system allows users to search for 'ideas' or 'contacts.' Agents can interpret natural language queries (e.g., asking about CI/CD steps) and provide contextually accurate answers based on stored knowledge.

  2. Structured Knowledge Flow 7:10

    Knowledge is categorized into 'company knowledge' (new developments, research wikis) and the 'creation pipeline.' Information must be promoted to a central vault from various sources (e.g., Obsidian notes, meeting transcripts) to gain grounding in reality before being shared widely.

  3. Scaling and Security Challenges 17:32

    While the system is powerful, scaling remains a challenge, particularly regarding data segregation (permissions) across different client or team buckets. The local setup on one person's laptop was initially used for testing, but enterprise rollout requires careful consideration of security boundaries.

Watch on YouTube Full article

· 16:56

Tessl Skills Clinic - Nnenna Ndukwe from Qodo

The session demonstrates how automated AI agent skills can be rigorously tested and improved using Tessl's review process against Anthropic's best practices. By applying human-guided refinements—particularly enhancing the skill description with natural trigger phrases and optimizing structure—the Qodo PR Resolver skill score jumped from 78% to 89%. This highlights that while AI generation is powerful, manual validation and refinement are crucial for achieving high-quality, reliable agent performance in production workflows.

Key takeaways

  1. Skill Description is Critical for Agent Triggering

    The skill's description metadata is identified as the single biggest factor determining if an agent will use it. Improving this by adding natural trigger phrases (e.g., 'coding issues,' 'code reviews') significantly increases discoverability and usage likelihood.

  2. Human Refinement Boosts Skill Quality

    Research suggests that while AI-generated skills are useful, validated and refined skills (human intervention) show a significant performance uplift. The average jump observed was approximately 14% for human-written skills.

  3. The Importance of Post-Fix Verification

    It is a best practice to include a validation step (e.g., running linters and static analysis) after an agent has applied fixes, ensuring the code remains compliant even after automated changes.

Watch on YouTube Full article

· 31:39

Simon Martinelli - Lessons from Spec-driven Development - AI Native DevCon June 2026

The talk introduces the AI Unified Process, a spec-driven approach designed to combat code and specification drift in large, long-lived enterprise applications. Instead of treating code as the source of truth, this method uses system use cases (specifically SysML use cases) and domain/entity models as stable contracts. AI is leveraged not for full regeneration, but for generating and updating code and tests incrementally from these specifications, enabling modernization efforts that are more robust than simple 'lift and shift' migrations.

Key takeaways

  1. Spec-Driven Development (SDD) as the Source of Truth 21:33

    System use cases act as a stable contract for application behavior. Code is derived from these specs, ensuring that changes are managed through formal requirements updates rather than relying solely on code maintenance.

  2. Modernization via Specification Extraction 23:50

    For modernization projects (e.g., ERP systems), the process involves reverse-engineering use cases and entity models from existing documentation, code, and tests. This allows for feature integration without being limited to a simple technology migration.

  3. Architectural Shift: Self-Contained Systems 27:20

    To effectively use AI in large systems, the architecture should move away from overly distributed microservices (which create context management issues) toward 'Self-contained systems'—vertical splits that keep UI, business logic, and database within a single project or application.

Watch on YouTube Full article

· 1:06:04

Why This Company Won't Let AI Agents Touch Bash

The presentation details the evolution of an internal AI agent platform at Cyera, transforming a personal assistant project into an enterprise-wide tool for data security and operational efficiency. The core focus is on building robust guardrails to prevent agents from becoming uncontrolled 'black boxes.' Key architectural innovations include whitelisting tools over blacklisting them, implementing a structured citation system for verifiable claims, and replacing traditional RAG with a Knowledge Graph (KG) that allows agents to navigate interconnected data like an LLM wiki. The platform emphasizes controlled deployment, allowing multiple developers to build and own specialized agents while maintaining centralized security and governance.

Key takeaways

  1. Controlled Agent Architecture

    The system prioritizes control by whitelisting specific tools rather than blacklisting forbidden actions. A critical guardrail is the use of structured, validated output, ensuring that an agent cannot execute arbitrary code (like unrestricted Bash) or leak sensitive data outside its designated context.

  2. Citation and Hallucination Mitigation 20:55

    To ensure reliability, every claim generated by the agent must be backed by a citation. This is achieved by forcing the model to output structured blocks containing both the claim and the source reference. A second model then performs clean-context verification against the raw data to drastically reduce hallucinations.

  3. Knowledge Graph over RAG 32:33

    The platform utilizes a Knowledge Graph (KG) instead of standard RAG for context retrieval. This allows agents to 'walk' connections between entities (e.g., an exception, a service, and the related pull request), providing more structured and reliable data exploration than simply dumping retrieved documents.

  4. Adoption through Platform Engineering 50:27

    To drive adoption across engineering teams, the platform was designed to be easily customizable. By allowing users to name and modify their own agents (e.g., 'It's my agent'), the barrier to entry is lowered, promoting organic growth with a strategy of 'carrots, not sticks.'

Watch on YouTube Full article

· 32:17

Jack Wotherspoon - Humans vs. Slop: Rewriting the Rules of Open-Source - AI Native DevCon

The rise of powerful AI agents is fundamentally changing open-source development by making code generation nearly free and abundant, leading to a flood of low-quality contributions ('AI slop'). This shift threatens the traditional human-to-human social contract of open source. Maintainers must implement new governance models—such as requiring issues before pull requests (PRs), rate limiting external contributors, and utilizing automation—to manage the influx of code while preserving quality and accountability.

Key takeaways

  1. The Open Source Shift 2:00

    Open-source development is moving from a human-to-human experience to one involving AI agents. The core challenge is that while generating code is cheap (sometimes free), reviewing, maintaining, and trusting the generated code remains expensive and difficult.

  2. Guardrails Against Slop 6:25

    To combat 'drive-by PRs' (where users submit fixes without prior discussion) and uncontrolled agent activity, maintainers should require contributors to file an Issue before submitting a Pull Request. This is cited as eliminating approximately 90% of drive-by PRs.

  3. Rate Limiting Contributions 7:00

    Implement rate limits on external contributors (e.g., limiting the number of active PRs) to prevent automated swarms of nonsensical code submissions, which can overwhelm maintainers.

  4. Trust and Governance Systems 9:40

    New systems are emerging to restore trust: 'Vouch' acts as a referral system for contributors, while 'Open Source Vacation' allows projects or solo maintainers to temporarily halt contributions when needed. Projects should also use context files (like `agents.md`) to guide all AI tools.

  5. Codifying Best Practices with Skills 11:20

    Implementing 'agent skills' (e.g., PR creator, docs writer) into the repository helps enforce best practices—such as running tests and following templates—for both human and AI contributors, thereby raising the overall quality bar.

Watch on YouTube Full article

· 32:31

Edouard Maleix - How AI-First Dev Teams Build Collective Intelligence — One Attributed Mistake at

The talk outlines a comprehensive workflow for transforming isolated agent mistakes and learnings into reusable, attributable collective intelligence within development teams. Instead of relying on simple documentation or context window stuffing, the proposed system introduces several primitives—Identity, Diary, and Knowledge Packs—to ensure that every incident, fix, and decision is captured, linked, validated, and made available to future work, thereby accelerating team learning beyond human pace.

Key takeaways

  1. The Problem with Isolated Learning 1:42

    Agents' small discoveries and incidents often remain trapped within a single session (e.g., closed PRs or chat history), leading to the evaporation of corrections and preventing knowledge from becoming reusable.

  2. The Need for Structured Knowledge Capture 3:58

    Teams need more than just a wiki; they require a 'knowledge factory' that catches mistakes, interruptions, and turns them into validated guidance. This knowledge must be constantly evolving (live, die) rather than static.

  3. The Importance of Agent Identity 14:15

    Giving agents a unique identity with signed commits and access rules solves the problem of attribution masking. It establishes a clear actor boundary, preventing agents from operating under human permissions.

  4. The Diary Primitive 15:30

    The 'Diary' serves as the central home for all discoveries and decision-making ('what the F moment'). It allows work/decisions to be linked to specific entries, providing reasoning beyond just diffs and commit messages.

  5. Creating Reusable Knowledge Packs 21:45

    The process involves capturing an incident (Entry) $ ightarrow$ grouping related Entries into a 'Pack' $ ightarrow$ rendering the Pack into usable markdown/context for the agent. This ensures lessons are traceable back to the original failure.

  6. Validation and Evaluation (Evals) 27:20

    To ensure quality, two types of evaluation are necessary: checking if the Pack is 'true to the entries' (fidelity) and running a task that reproduces the original incident using the knowledge pack to measure improvement (usefulness).

Watch on YouTube Full article

· 31:16

May Walter - From Blind Spots to Merged PRs: Runtime Intelligence for Continuous Agentic Performance

The talk details implementing a runtime intelligence layer for coding agents to enable continuous performance optimization in mature codebases. The approach moves beyond reactive bug fixing by running sensors in production to capture deep forensic context (e.g., function execution frequency, failure modes). This allows agents to proactively surface high-ROI fixes—such as N+1 queries or missing database indexes—scored by complexity and impact, enabling tech leads to prioritize improvements before sprint planning.

Key takeaways

  1. Automating the Investigation Phase 17:52

    Instead of waiting for performance degradation to become a crisis (a 'leaky bucket' problem), the goal is to automate the investigation phase. This allows teams to identify potential optimizations and their estimated impact/cost without dedicating unpredictable engineering time.

  2. Prioritizing Impact over Task Completion 25:30

    The focus shifts from merely generating pull requests (PRs) to identifying the highest impact, lowest risk changes. The system must provide human-readable context that justifies attention, preventing 'PR fatigue' from agents.

  3. Defining Business Context 22:00

    Effective agentic workflows require more than just code analysis; they need business context. The system must map production activity (endpoints, event consumers) to function-level context to understand the true impact of a potential fix.

Watch on YouTube Full article

· 36:51

Daniel Jones & Tomasz Maj - More software, faster - Odevo's AI Native transformation - AI DevCon '26

Odevo details its AI-native transformation journey, moving from a highly heterogeneous tech landscape across multiple acquisitions and time zones. The core message is that adopting generative/agentic coding practices requires more than just providing licenses; it demands fundamental improvements in organizational processes, including robust CI/CD pipelines, standardized coding guidelines, and cultural shifts toward 'boldness' and experimentation. By systematizing training and focusing on failure modes, Odevo achieved significant metrics increases, such as 94% AI adoption among developers.

Key takeaways

  1. AI Adoption Requires Process Maturity 20:03

    Adopting agentic coding is not simple. Success hinges on foundational elements like having a reliable CI/CD platform, standardized coding practices, and comprehensive testing protocols. Without these fundamentals, generating code quickly will only expose bottlenecks elsewhere.

  2. The Importance of Discovery and Workshops 23:50

    Successful AI transformation requires a 'discovery' phase to understand the current state (the 'lay of the land') and using workshops (e.g., employing techniques like TRIZ) to address employee fears, reduce hesitancy, and build consensus on necessary improvements.

  3. Focus on Failure Modes 27:10

    Training should not focus only on the 'happy path.' It is crucial to teach developers about failure modes (e.g., context management, hallucination) and how agents operate in complex environments.

  4. The Biggest Impact is Boldness 32:10

    The most significant outcome of the AI transformation was not just increased efficiency but a cultural shift toward 'boldness'—the willingness to try ambitious, end-to-end agentic workflows and rewrite large systems quickly.

Watch on YouTube Full article

· 31:32

Peter Wilson & Davide Eynard - cq - Stack Overflow for Agents - AI Native DevCon June 2026

The session introduces CQ (Mozilla.ai's proposal), a system designed as a 'Stack Overflow for agents.' Its core purpose is to standardize and share knowledge units (KUs) across autonomous AI agents—locally, within an organization, or publicly. This prevents agents from repeating mistakes, wasting tokens, and ensures that lessons learned by one agent can benefit all others, thereby improving the reliability of complex automated workflows.

Key takeaways

  1. Knowledge Unit (KU) Standardization 17:09

    A KU is a standardized knowledge artifact (stored in JSON format) capturing solutions to novel problems. It includes domains, insights, actions taken, summaries, and metadata (languages/frameworks).

  2. Agentic Context Management 6:15

    Effective agent performance relies heavily on context injection. The system aims to move beyond simple memory files by allowing agents to query a centralized knowledge base for relevant solutions before starting a task.

  3. Layered Sharing Model 20:40

    CQ supports three levels of knowledge sharing: local (SQLite database, no review), private/team (requires user authentication and human-in-the-loop review), and public commons (CQ Exchange).

Watch on YouTube Full article

· 32:39

James Moss - Using skills to pay the bills: graduating from solo hacks to a team workflow - DevCon26

The talk addresses the challenge of 'skill sprawl'—the uncontrolled proliferation and management of AI coding agent skills within large organizations. While skills are powerful because they encode domain-specific logic into an agent's context, their current lack of standardized versioning, review, and centralized governance creates significant technical debt. The speaker advocates for treating skills as first-class software assets, requiring dedicated practices like decomposition, mandatory registries, automated reviews, and formal lifecycle management (CDLC) to ensure reliability and scalability.

Key takeaways

  1. Manage Skill Sprawl with a Centralized Registry 17:33

    Due to the low barrier to entry for creating skills, organizations face an 'insane amount' of them (2 million+ on GitHub alone). A centralized registry is crucial for visibility, preventing overlap, and ensuring all teams use approved versions. This also helps mitigate non-technical users needing access without requiring full developer seats.

  2. Adopt the Context Development Life Cycle (CDLC) 27:50

    Just as code requires a Software Development Lifecycle (SDLC), skills and context require their own CDLC. Practices like skill reviews, automated testing, and version control must be applied to maintain quality and prevent 'rot' (skills going out of sync with the codebase).

  3. Decompose Skills for Modularity 20:40

    Instead of creating monolithic skills, break complex functionality into smaller, interconnected plugins. This allows agents to activate specific components and makes the skill set easier to maintain and debug.

  4. Enforce Governance via Registries 22:30

    Using a registry provides a single source of truth, allowing organizations to enforce policies (e.g., 'approved skills only,' minimum release age) and integrate security scanning tools like Snyk.

Watch on YouTube Full article