Topic

Testing Methodologies

All digests tagged Testing Methodologies

· 6:06

The Future of Evals: From LLM as a Judge to Agent as a Judge — Aparna Dhinakaran, Arize AI

The complexity of modern AI agents—which now incorporate reasoning, tool calls, and long multi-step loops—has rendered traditional evaluation methods insufficient. The talk argues that the future of evaluating these systems lies in moving from static deterministic checks or fixed LLM rubrics to 'Agent as a Judge,' which performs adaptive dynamic analysis to uncover subtle failure modes.

Key takeaways

  1. Evals are critical for AI maturity

    Evals have become essential for serious AI teams, with the industry noting that they catch all failures and fuel continual learning loops. Arize reports running over 100 million evals monthly.

  2. Agent complexity breaks traditional evals 3:26

    As agents evolved from simple prompt answering (2023) to complex, multi-step loops with sub-agents and dynamic UI creation, the failure modes became fundamentally different, exceeding the scope of classical LLM as a Judge checks.

  3. The future requires adaptive evaluation 5:45

    While deterministic checks and LLM-as-a-Judge are valuable, the next step is 'Agent as a Judge,' which provides adaptive dynamic analysis to find failure modes that were previously undetectable.

Watch on YouTube Full article

· 58:11

Responsibly Abandoning Open Source Projects - Jason Turner - NDC Copenhagen 2026

This talk outlines best practices for developing and maintaining open-source projects to ensure they can be responsibly abandoned or handed off years later without becoming 'legacy' or 'abandoned.' The core focus is on achieving a state of 'completeness' by implementing rigorous automation across the entire development lifecycle—from static analysis and comprehensive testing (including path coverage, fuzzing, and mutation testing) to simplified build processes. Key recommendations include automating all quality gates within CI/CD pipelines and minimizing technical debt related to tooling complexity.

Key takeaways

  1. Achieve 'Completed,' Not 'Abandoned' 20:30

    When concluding work on a project, aim for the status of 'completed' rather than 'abandoned.' This requires proactive measures like maintaining clear documentation and ensuring continuous automation.

  2. Automate All Quality Gates 29:55

    Implement automated checks for every possible tool (static analysis, dynamic analysis, formatting) to ensure consistency and reduce friction for future maintainers. This should be fully integrated into the build process.

  3. Prioritize Strong Typing 34:45

    Adopting strongly typed systems (e.g., using type hints in Python or dedicated types like `Point` and `Color`) makes code less prone to order-of-operations errors, significantly improving robustness.

  4. Minimize Build Setup Friction 32:10

    A new contributor should be able to set up the development environment and run all tests/analysis in a minimal number of steps (ideally five lines or less).

Watch on YouTube Full article