Agentic Engineering restructures software development by prioritizing structured principles, automated agents for iterative refinement, and efficient AI integration, while redefining testing and team roles to adapt to evolving AI capabilities. Challenges include managing AI behavior shifts, balancing agent autonomy with control, and overcoming organizational hurdles like siloed teams through collaborative, iterative practices.

Richard Seidl Software Testing

This is the other podcast on Software Testing by Richard Seidl, the episodes are in spoken German but the show notes and site are written in English. Our summaries are generated from AI transcript translations.

• https://www.richard-seidl.com/en/blog/tag/podcast-software-testing
• https://www.richard-seidl.com/en/

Episode Details

• Show Notes: https://www.richard-seidl.com/de/blog/agentic-engineering
• Published: 2026-05-19T04:00:00Z
• Duration: 00:31:29
• Author: Richard Seidl - Experte fur Software-Entwicklung und Testautomatisierung

Overview

The podcast discusses Agentic Engineering, a rebranded approach to systematizing software development that emphasizes engineering principles, architecture, and quality assurance over casual or ad-hoc coding. This framework leverages automated agents to perform tasks like refactoring, simplification, and error detection iteratively, with refactoring treated as a retrospective process to refine systems. It highlights the importance of strong foundational principles in AI integration, which enable faster progress and better outcomes, while poor principles accelerate decline. Testing strategies are scrutinized for inefficiency, with a push toward faster feedback mechanisms and less reliance on traditional testing without error detection. The discussion also addresses the role of architects in prioritizing system design and maintainability over code specifics, alongside the need for clear documentation and predefined values to guide agent behavior effectively.

Key challenges include the evolution of AI model behavior, where newer models like Codex 4.6/5.3 prioritize adaptation over content generation, necessitating careful configuration and the discarding of outdated skills. A layered model workflow is proposed, using high-cost models for complex planning and cheaper ones for execution to balance efficiency and cost. The shift toward agent autonomy and reduced dependence on explicit prompts is explored, with agents relying on pre-configured context and reverse engineering to identify necessary tools and corrections. Additionally, the podcast examines the implications of AI integration in software systems, from reshaping team structures into cross-functional, hybrid roles to addressing organizational and architectural challenges like Conways Law and the limitations of siloed teams. It underscores the need for collaboration, iterative retrospectives, and rethinking traditional practices like requirement specifications and testing to adapt to AI-driven development. Finally, while challenges persist in testing, QA strain, and balancing abstraction with responsibility, the conversation reflects optimism about evolving methodologies and ongoing efforts to refine agent-centric workflows.

What If

• What if you deploy a cleanup agent to refactor your core codebase overnight?

  • Move: Implement a dedicated cleanup agent using predefined values (e.g., “simplification,” “maintainability”) to automate refactoring, removing technical debt, and optimizing for readability.
  • Why now: Agentic Engineering prioritizes systematic cleanup without developer intervention, and your codebase likely accumulates debt faster than you can address manually.
  • Expected upside: Faster iteration cycles, reduced manual effort, and a leaner codebase ready for feature development.

• What if you configure your agents with a system prompt instead of micro-managing tasks?

  • Move: Define a 20,000-token system prompt outlining your priorities (e.g., “prioritize code safety over speed,” “use modular architecture”) and let agents autonomously apply these rules.
  • Why now: The text notes that agent behavior is increasingly shaped by pre-configured context, reducing reliance on explicit prompts. This aligns with modern agent workflows.
  • Expected upside: Streamlined agent interactions, fewer back-and-forth corrections, and consistent output aligned with your long-term vision.

• What if you split tasks between a state-of-the-art model (e.g., Opus) and a cheaper model (e.g., Haiku)?

  • Move: Use Opus for high-level planning, architecture decisions, and edge cases, then delegate implementation to Haiku for cost efficiency.
  • Why now: The production line approach advocates task-specific model selection, which reduces costs while leveraging advanced models for critical decisions.
  • Expected upside: Lower operational costs without sacrificing quality, and faster delivery of features through optimized resource allocation.

Takeaway

• Automate Code Refactoring with Agents: Use agents to handle repetitive tasks like code cleanup and simplification by defining clear directives (e.g., “optimize for maintainability”) and leveraging existing knowledge bases for structured improvements.
• Prioritize State-of-the-Art Models: Adopt advanced models like Opus 4.6 or Codex 5.3 for critical tasks, discarding outdated configurations to avoid limiting performance, and reevaluate default behaviors when transitioning to newer models.
• Implement Faster Feedback Mechanisms: Replace over-reliance on exhaustive testing with tools like “Slash Insights” to automate retrospective analysis and capture actionable insights, speeding up development cycles.
• Define Explicit System Values for Agents: Establish clear, non-vague metrics (e.g., “reduce technical debt”) for agents to prioritize optimizations, ensuring alignment with long-term code quality goals rather than generic terms like “good quality.”
• Adopt a Layered Model Workflow: Use cost-effective models (e.g., Haiku) for implementation tasks and reserve expensive models (e.g., Opus) for high-level planning or complex decision-making to balance efficiency and cost in production pipelines.