Developing Software with AI
About Course
Developing Software with AI is a 20-hour hands-on course that gives developers a disciplined process for gaining the speed of AI without losing engineering judgment or control.
You will build one application through changing requirements while practicing collaboration, test-first development, continuous integration, CLEAN code, and emergent design. You will leave able to guide AI-assisted development from intent through verified software your team can explain, trust, and continue to evolve.
Most developers begin by asking AI to solve a problem or generate a feature. The result may look convincing and may even work, but it can introduce assumptions, unnecessary complexity, and code the team does not fully understand.
This course gives you a different way to work. You will learn to begin with the need, establish shared domain language, define concrete behavioral examples, and turn understanding into executable tests. You will build and integrate one understood change at a time, evaluate both human- and AI-generated code, and refactor only when real variation earns a more advanced design.
Across five four-hour sessions, you will build ToolShare, a community tool-lending application. The system begins with one simple loan and grows to include meaningful variations, interacting policies, external dependencies, and an unexpected change. Each new requirement gives you practical experience deciding when to keep the design simple and when to let it evolve.
The course interleaves concise teaching with programming labs, change reveals, debriefs, and group discussion. Core challenges, optional extensions, and tested recovery checkpoints allow participants to work at different speeds while remaining part of one shared learning journey.
By the end of the course, you will have more than a collection of AI techniques. You will have a repeatable development process, greater confidence in your own technical judgment, and a practical way to collaborate with AI while preserving the understanding that makes software changeable.
About the Instructor
David Scott Bernstein is the author of Beyond Legacy Code and co-author of Prompt Engineering for Everyone. He has trained more than 10,000 professional developers in Extreme Programming, test-first development, domain modeling, design patterns, and the practices that make software understandable, testable, and changeable. David helps developers gain the leverage of AI while strengthening the judgment and agency that make their work valuable.
About the Learning Experience
Developing Software with AI is instructor-led technical training built around one evolving application. Participants learn through a repeated rhythm of framing the need, predicting, building, comparing, naming what they discovered, responding to change, and distilling practical habits they can use with their own teams.
The course combines the depth of a mature software-development curriculum with the experimentation required for a new way of working. AI participates throughout as a collaborator, but participants remain responsible for intent, validation, design decisions, and the quality of the software they create.
Next Steps
Interested in bringing Developing Software with AI to your team? Let’s begin with a conversation about how your developers currently work, where AI is helping, and where understanding or quality may be falling behind. There is no pressure to adopt a particular tool or approach. The first step is simply deciding whether this learning experience fits your team and that starts with a conversation.
Schedule a call with me here.
https://tidycal.com/talk-to-david/consultation-with-david
David
David Scott Bernstein, The Passionate Programmer
What Will You Learn?
- Collaborate with developers and AI using explicit intent, shared language, and clear validation.
- Turn ambiguous needs into concrete examples and executable behavioral tests before implementation.
- Build and integrate one understood behavior at a time instead of accepting large generated changes.
- Evaluate human- and AI-generated code using CLEAN qualities and keep the domain model independently testable.
- Recognize when a simple design remains sufficient and when repeated variation has earned an abstraction.
- Refactor safely as the model evolves, then explain and defend the resulting design without relying on the AI conversation.
