Jeff Haemer has been writing software since he was teaching it at the University of Colorado in the early 1980s. That's not a flex—it's context for why his recent admission that AI felt like "a big undifferentiated cloud of things I didn't know" carries weight coming from him. The guy's seen waves come and go. But when he describes what happened after six weeks inside a Python Agentic AI cohort, you can hear the shift in how he thinks about building software now.

The Cohort Approach

Haemer signed on as the beta tester for a program that promised something most tutorials don't: a production-ready agent by week six. Not another API wrapper. Not a Jupyter notebook that works once. An actual deployed system with function calling, structured outputs, three interfaces (web UI, command line, and a Telegram bot), Docker, and 95%+ test coverage. The cohort structure forced him to ship real engineering—thousands of lines of code, nearly 250 unit tests, and 100% coverage. "When you told me you were thinking about doing an AI cohort, I said please do that and sign me up," Haemer said. "I will happily jump in feet first." He set expectations deliberately low. "I expected myself to crash and burn because I have a very spotty background."

Core Logic First, Interfaces on Top

The cohort's architecture philosophy became its own lesson: build the reasoning core first, wrap interfaces around it later. That structure got tested hard during the Telegram integration week, when connecting the agent to a chat app hit a wall. "I got to the end of that week and I wasn't even close," Haemer admitted. "And I said, okay, I failed you." But the instructor's response revealed the design intent: go on to the next week because those units were built independent of one another. The team rewrote the Telegram material from almost 100 pages down to 41, starting from a simpler working version. When Haemer returned to it later, it worked. "It was beautiful," he said. "When we hit a speed bump, that worked. It proved itself." This is the meta-lesson most AI tutorials skip entirely—build the thing that does the work first, keep the edges replaceable. If your agent can't survive an interface swap without collapsing, you built it wrong.

The Mocking Wall

The concept that gave Haemer the most trouble wasn't LLM prompting or tool calling—it was mocking. The practice of replacing real outside services (APIs, databases) with stand-ins so tests can run fast and offline. "I even asked a friend of mine, a test automation Python guy, and he said I never really understood that either," Haemer admitted. He avoided it until week four or five, when the cohort made it non-negotiable. "You got me to the point where I could actually separate my unit tests—which were independent of outside services—from my integration tests," he said. "I learned stuff about pytest, I learned stuff about mocking, and I learned stuff about my own code. I just ended up thinking about things in a different way." That rigor paid off: his test suite caught a function that slipped coverage when he deployed to a Debian box—something he tracked down independently.

AI as Teaching Assistant, Not Autopilot

Here's where Haemer's approach diverges from the cargo-cult pattern you'll see everywhere else. He wrote the code by hand. He used AI deliberately, as a tutor for the spots where his Python ran out—not as a generator to fill the file for him. "I understand conceptually what to do here, but I don't know enough Python to struggle through the docs and work through all the bugs in that short amount of time," he explained. "So, show me how to do this. AI turns into a great teaching assistant." Unit tests gave each week a definition of done. The result was an artifact he could reason about, not a diff he had to trust on faith.

Key Takeaways

  • Build the reasoning core before interfaces—keep edges replaceable from day one
  • Mocking isn't optional for production agents; it's what lets you test without hitting real APIs
  • Use AI as a teaching assistant that explains, not an autopilot that generates
  • Writing code by hand with tests gives you ownership and understanding that copy-paste tutorials never will

The Bottom Line

Most AI tutorials end at "call the API." This cohort ended with deployment. But Haemer's real win wasn't the repo—it was developing a mental model he could trace through an actual agent. He tested it against a hallucinating Wikipedia clone and could walk through exactly what happened: validate input, structure it, hand to the model, get structured output back, cache in database. That's not something you get from watching someone else do it. That's earned understanding.