So, you let AI generate some code, then spend time manually validating it. So much for those promised productivity gains. But, wait! Why would you do that? You wrote tests, right? Why not prompt AI with something you can use to validate its output? Why not prompt AI with automated specifications?!

Sure, AI can generate code. But, do you trust it? Probably not. You probably spend a bunch of time examining the code to verify that it is correct. So much for those promised productivity gains!

But, wait! Why would you do that? You wrote automated tests, right? Why not just run your tests? Better yet, why not prompt AI with automated specifications and let it figure out how to make them pass?

Come join us as we look into whether or not today’s LLMs are up to the task, explore techniques for writing self-validating prompts, and dream about the future of developer tools.

Why This Talk?

Whether you like TDD or not, automated specifications are the future of software development. We need a way to specify what we want AI to generate. And, we need a way to prove that AI generated what we wanted. The solution is obvious: automated specifications.

That’s different from automated tests, which are often written after the fact and with knowledge of the implementation. Automated specifications are almost always written before the fact and without any knowledge of the implementation. Therefore, they specify externally visible behavior and treat the software itself like black box, which is a perfect fit for generated code.

In our testing, the largest, most advanced LLMs had no problem generating a class that passes a small test suite. They produced different implementations, but ChatGPT, Claude, and Deepseek all passed every test on the first try. Copilot passed all but one of the tests.

In other words, code is already becoming less relevant. We did look at the code to understand it ourselves. But, we didn’t need to. The tests told us everything we needed to know. In fact, in the future, we may not even care what language the computer chooses, which makes us wonder what a language-agnostic, specification-driven, LLM-backed development environment would look like.

In this talk, we will:

• Make the case that learning TDD, now, will future proof your career.
• Contrast well written specifications with other types of automated tests.
• Show how good today’s LLMs are at writing code that passes tests.
• Dream about how LLM-based developer tools can incorporate the TDD feedback loop.

Why these speakers?

We are seasoned speakers:

• We’ve spoken together at meetups and conferences across the U.S. and abroad to audiences ranging from 50 to 500 people, including RailsConf, RubyConf, Tropical.rb, and others.
• Our talks attract audiences and are routinely praised by attendees.

We are experts:

• We are both passionate Rubyists, each with 14 years experience.
• We are both deeply experienced TDD practitioners.
• We use AI every day to generate tests and code.
• We write behavior-centric, implementation-agnostic specifications.
• We know the pain associated with implementation-specific tests.
• We work in one of the largest, most successful Rails apps on Earth!

Intended Audience

Software developers, at all levels, who are looking for insight into what their careers will look like once code becomes irrelevant — especially those who might want to try to shape that future.

High Level Outline

• Introduction (2 minutes)
• Make the case that learning TDD, now, will future proof your career. (2 minutes)
• Contrast well written specifications with other types of automated tests. (8 minutes)
• Show how good today’s LLMs are at writing code that passes tests. (Spoiler alert! They’re getting really good at it!) (8 minutes)
• Dream about how LLM-based developer tools can incorporate the TDD feedback loop. (8 minutes)
• Conclusion (2 minutes)