What Does It Really Mean To Program With AI: A Conversation with Joy Ebertz

The podcast discusses the evolving role of software architects, emphasizing that architectural responsibilities often develop organically through experience rather than formal titles. The guest highlights the importance of balancing technical depth with business needs, addressing non-functional requirements like scalability and security, and effectively communicating trade-offs across technical and non-technical teams. The conversation also explores the shift between monolithic and microservices architectures, with considerations around how AI-assisted development may favor modular systems due to clearer boundaries and easier pattern replication.

A significant portion of the discussion focuses on the impact of AI on software development, particularly in generating and maintaining code. The guest notes that while AI can efficiently produce code - especially in constrained or well-documented contexts - it struggles with ambiguity, complex system orchestration, and critical areas like security and authorization. Testing, clear requirements, and human oversight remain essential to ensure correctness and maintain system integrity. Concerns are raised about the long-term sustainability of relying on AI, including risks of losing foundational technical knowledge and challenges in training junior engineers to use AI effectively without sacrificing core coding skills.

• What if you restructured your solo project into microservices to improve AI collaboration?

  • Move: Break your monolithic codebase into 2 - 3 well-scoped microservices (e.g., auth, core logic, reporting) with clear REST APIs and boundaries.
  • Why Now?: AI performs better with modular, constrained systems - especially for regeneration and bug fixes - and you're already maintaining the code solo, so rearchitecting now limits downstream tech debt.
  • Expected Upside: Faster AI-assisted development cycles, easier regeneration of broken services, and improved long-term maintainability with clearer ownership per module.

• What if you treated tests as your primary contract for AI-generated code?

  • Move: Shift from writing implementation-first to writing comprehensive, behavior-defining tests before any AI code generation (e.g., using TDD-inspired workflows for critical paths like authorization).
  • Why Now?: As AI takes on more coding tasks, ambiguous requirements lead to "slop"; well-defined tests act as enforceable specs and guardrails against regressions or hallucinations.
  • Expected Upside: Higher reliability of AI outputs, reduced need for manual code reviews, and a living documentation system that ensures consistency across solo-developed features.

• What if you delegated routine feature work to AI while focusing your efforts on architectural constraints and domain modeling?

  • Move: Use AI to generate boilerplate or CRUD features, but personally define and document domain boundaries, authorization rules, and integration contracts upfront.
  • Why Now?: AI excels at constrained tasks but fails at high-level system design; as a solo operator, your highest leverage is setting structure - not writing repetitive code.
  • Expected Upside: 3 - 5x faster feature delivery with AI execution, while maintaining system coherence, security, and scalability through your focused architectural oversight.

• Define and document clear system requirements and constraints before using AI to generate code, ensuring the AI operates within well-scoped boundaries to reduce errors and misinterpretations.
• Invest in robust, automated testing early - especially for AI-generated code - so that correctness can be validated consistently, even when code is regenerated or refactored.
• Break complex systems (like authorization) into smaller, domain-specific modules to make them more manageable for both human understanding and AI assistance, avoiding monolithic logic that's hard to maintain.
• Use AI as a pair programmer rather than a fully autonomous coder; actively review and refine AI output, particularly in critical areas like security, performance, and integration logic.
• Prioritize teaching junior developers fundamental coding and problem-solving skills without over-relying on AI, using structured methods like non-AI coding tasks or supervised pair programming to build foundational knowledge.