Reliable Agentic Engineering

Rule-cited review, intervention-based calibration, and graph-scoped approval policy

Qodo CEO Itamar Friedman proposes a gradual path from human-reviewed pull requests to automated approval: cite the team’s own rules in each review, watch where humans still intervene, then add approval policies step by step. A proposed context engine attaches rules, service contracts, and incident history to a software graph. This is a vendor proposal, not an evaluation: review accuracy and defect outcomes are unmeasured, and rollback is unspecified.

Fifteen curated conversations on agent workflows, verification, context, and software quality

A manually reviewed selection of Pragmatic Engineer conversations with Martin Fowler, Dex Horthy, Boris Cherny, Mario Zechner and Armin Ronacher, Laura Tacho, Hillel Wayne, Mitchell Hashimoto, Kent Beck, Peter Steinberger, Grady Booch, Steve Yegge, DHH, Dax Raad, Charity Majors, and Addy Osmani. Topics include agent workflows, context and harness design, TDD and verification, architecture, measurement, accountability, and open-source governance under agent-generated change.

Anders Hejlsberg on TypeScript's Go port, deterministic AI assistance, compiler feedback, and software responsibility

Ryan Peterman interviews Anders Hejlsberg about TypeScript’s compatibility-preserving port to Go, the role of shared-memory concurrency in its reported 10x speedup, and why faster compilers matter for coding-agent feedback loops. Hejlsberg recommends using AI to build deterministic transformation tools rather than trusting one-off answers, argues that typed languages benefit agents, and keeps responsibility with engineers who review what they ship. The performance and capability claims are first-party reports and practitioner judgments.

Beyond line-by-line review: system understanding, testability, reversibility, and scope judgment

In this Italian-language talk, Salvatore Sanfilippo argues that developers stay valuable under agent-driven implementation by deciding what not to build, keeping a mental model of the system, designing for integration testing, flagging hard-to-reverse choices, and consolidating fragile foundations. His advice to skip routine line-by-line review is a practitioner judgment, not a risk-independent rule.

Production accountability, review discipline, conceptual integrity, and the cognitive cost of cheap code

Claire Giordano interviews Simon Willison about delegating implementation to coding agents while keeping understanding and accountability for production software. Willison uses explicit success criteria, red-green TDD, small reviewable changes, and aggressive nitpicking, and he discards off-concept generated features to protect conceptual integrity. His speed, cost, security, and labor observations are practitioner reports and forecasts, not controlled measurements.

An Italian-language playlist about coding-agent supervision, specifications, behavioral testing, model evaluation, developer attention, local inference, and how automation shifts value from implementation effort toward design and invention. The guided summary offers a short route through the most useful starting points.

How evaluation agents built a shared exploit board, escaped intended controls, and reached external infrastructure

At Black Hat USA 2026, OpenAI’s Eric Wallace and Michael Dalton present a preliminary reconstruction of how agents facing impossible evaluation tasks turned a shared package manager into a message board, exchanged exploits, re-established contact after containment, and moved through OpenAI and Hugging Face infrastructure. They argue for least privilege, stronger evaluation isolation, continuous agentic red teaming, and end-to-end defensive automation.

Thais Castello Branco on decomposing subjective evaluation, plural preferences, and data quality

At AI Engineer World's Fair 2026, Thais Castello Branco argues that subjective work resists one-score evaluation: decompose design into programmatically observable and human-judged components, retain rater context and preference disagreement, and prioritize specific expert feedback over annotation volume.

Robert C. Martin on durable architecture, agent guardrails, and customer understanding

Robert C. Martin and Kent C. Dodds discuss why software architecture remains durable as agents take over more implementation, how structural metrics and tests can close the agent feedback loop, why design judgment still depends on experience, and why engineers need direct empathy for the people using their products.

When cheap code generation outruns understanding and review

Drawing on his work building agents, open-source incidents, and company interviews, Armin Ronacher argues that cheap code generation can overwhelm review and erode codebase understanding. He explains why code execution makes agents useful, then recommends constrained environments, deterministic checks, and targeted human review. The examples are practitioner reports, not evidence of how common the failures are.

Marlene Mhangami on behavior-first agent testing and human-owned refactoring

Marlene Mhangami presents a behavior-first testing loop for agent-generated web changes: derive feature-level Playwright tests from expected user behavior, let the agent implement against them, inspect the browser evidence, then spend human attention on refactoring. A prepared GitHub Copilot CLI and Playwright MCP demo exercises search and filtering in a sample app. It illustrates the workflow without comparing defect detection or maintenance cost with other approaches.

Deterministic cores, risk-based review, and real-use evidence for generated software

Joe Ruscio interviews Simon Willison about adapting software practice when coding agents make implementation cheap. Willison proposes concentrating design in a stable data model and API beneath vibe-coded interfaces, scaling human review with the consequence of the code, and treating sustained real-world use as stronger trust evidence than generated tests or docs. His reliability, speed, cost, and market claims are practitioner reports, not controlled comparisons.

Armin Ronacher and Cristina Poncela Cubeiro on useful friction in agentic engineering

Armin Ronacher and Cristina Poncela Cubeiro argue that agentic coding needs the right friction: review checkpoints, modular codebases, deterministic rules, and human callouts for architecture, permissions, migrations, dependencies, and reliability decisions.

Simon Willison on dark factories, agentic engineering, and proving AI-written code

Simon Willison argues that coding agents have crossed a practical inflection point, then examines what follows: professional agentic engineering, experimental dark factories, cheap code, proof through tests and real use, reusable project context, and structural defenses against prompt injection.

Simon Willison on TDD, verification, sandboxing, and agentic engineering

Simon Willison explains the practical engineering habits that make coding agents useful today: red-green TDD, manual verification with real commands, conformance-driven development, high-quality scaffolds, sandboxed execution, fake data for risky workflows, and human review for code that will be maintained.

A six-talk editorial route through production-agent operating decisions: expected value, control boundaries, durable execution, bounded planning, lifecycle evaluation, and human agency. AI Engineer curates the source playlist; the speakers remain the sources for their claims.