How Senior Engineers Use Coding Agents On Prod Infrastructure

The podcast discusses the evolving role of automation, particularly through Infrastructure as Code (IaC) and AI-driven agents, in modern software development. A strong emphasis is placed on Terraform and its ecosystem, highlighting how open-source modularity, API-first design, and provider improvements have enabled more reliable and scalable infrastructure management. Services that support full Terraform integration - such as Okta, Datadog, and Contentful - are favored for their ability to streamline workflows, reduce manual effort, and enhance engineering efficiency. The discussion also explores how agents can automate repetitive tasks like dependency updates and testing, but stresses the need for clear specifications, constraints, and human oversight to prevent errors such as unintended resource deletions.

Challenges around agent reliability, decision-making, and integration into CI/CD pipelines are examined, with concerns raised about non-deterministic behavior, inherited historical mistakes, and the risks of over-reliance on AI without proper verification. The concept of "software factories" is introduced as a way to standardize agent-driven workflows while balancing consistency and creativity. Additionally, the importance of intentional design, architecture, and planning is underscored, drawing parallels to traditional engineering disciplines. The conversation extends to documentation practices, advocating for clarity through techniques like BLUF (Bottom Line Up Front) and filtering out noise to improve human decision-making. Ultimately, the focus shifts toward building personalized, high-quality software rooted in real needs, driven by passion and iterative improvement rather than rapid, low-effort output.

• What if you automated your entire infrastructure provisioning workflow using AI agents and Terraform?

  • Move: Set up an agent-assisted pipeline where AI drafts Terraform PRs for common infrastructure tasks (e.g., adding a new service in AWS), then automatically runs terraform plan and summarizes changes in plain language for your approval.
  • Why Now?: Terraform providers are now mature and API-first services dominate; combining them with agent tooling reduces manual toil while recent incidents (e.g., Cloudflare provider bugs) show the need for pre-deployment validation that agents can enforce consistently.
  • Expected Upside: Cut infrastructure change lead time by 60 - 80%, reduce human error in repetitive setups, and free up 5 - 10 hours/week for higher-value architecture work.

• What if you treated every open-source dependency update as a test case for agent reliability?

  • Move: Configure an agent to auto-generate and submit PRs for dependency updates (e.g., Terraform provider versions, npm packages), but require it to include a changelog summary, risk assessment (e.g., breaking changes), and verification steps you can quickly validate.
  • Why Now?: With agents increasingly contributing to open source and generating code, delaying updates due to testing overhead is a growing bottleneck - this lets you leverage automation while maintaining control over quality and safety.
  • Expected Upside: Maintain up-to-date dependencies with minimal effort, detect problematic updates before they break production, and build a reusable verification framework that improves over time as the agent learns from your feedback.

• What if you built your own "software factory" for personal projects using specification-driven development?

  • Move: Define a lightweight spec template (e.g., goal, constraints, required APIs, Terraform modules to use) and train an agent to only act when such a spec is present - forcing it to draft code, docs, and infrastructure in alignment with your standards.
  • Why Now?: The shift toward agent-driven workflows risks chaos without structure; codified services (Okta, Datadog, etc.) and mature IaC tools make it feasible to enforce consistency even as output volume increases.
  • Expected Upside: Ship higher-quality, maintainable projects faster by eliminating ad-hoc decisions, reduce rework from misaligned outputs, and create a repeatable system that scales across multiple solo ventures.

• Implement Infrastructure as Code (IaC) using Terraform for all cloud resources, prioritizing services with strong APIs and official Terraform providers to ensure automation and replicability.
• Set up agent-assisted workflows with clear constraints and verification steps - such as pre-deployment checks and human approval for destructive actions - to safely automate infrastructure changes.
• Filter and summarize automated output (e.g., pull requests, dependency updates) to focus on high-impact changes, reducing noise and improving decision speed in solo development.
• Build or adopt a minimal "software factory" framework that enforces personal standards (e.g., preferred languages, documentation format, testing) to maintain consistency across AI-assisted and manual work.
• Start software projects by solving a personal pain point, then validate demand through early user feedback, ensuring the product has a unique angle and sustainable motivation behind it.