Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

TDD in Action with AI: From Fundamentals to Production

Name: TDD in Action with AI: From Fundamentals to Production
Rating: 4.9 (22 reviews)

Use Test-Driven Development and AI to build Production-Ready Software, with Kotlin & Spock

Highest Rated

Created byNikos Voulgaris

Last updated 3/2026

English

What you'll learn

Build real-world applications from scratch using Test-Driven Development (TDD)
Write fast, deterministic, and isolated unit tests that act as both living documentation and a safety net for refactoring
Design and test RESTful APIs using the Outside-In TDD methodology
Use AI tools to enhance your development workflow and boost productivity — without sacrificing control
Master the core principles and techniques of TDD, and apply them confidently in production code

Course content

7 sections • 78 lectures • 3h 31m total length

Introduction1:33
Course structure1:52
Environment setup0:29

Section intro0:51
Github repo0:31
How we test software2:07
Test pyramid2:37
Explore how the test pyramid stacks unit, functional, end-to-end, and manual tests, and why higher levels cost more to execute and write.
What's a unit test1:57
Why bother writing unit tests2:42
Naming4:45
Readability2:46
The AAA rule3:04
The Single Assertion rule3:45
Always watch the test fail2:07
Isolation3:27
Mocking (stubs)4:52
Mocking (dummy objects)2:06
Testing behavior vs testing state3:01
Wrap up1:13
Recap essential testing concepts, including the test pyramid, unit tests, readable naming, and the arrange-act-assert with given-when-then, plus isolation and mocking in TDD.

Section intro0:48
Write code using test driven development to build the task manager's application logic, exploring triangulation and fake it till you make it through a bold refactor.
Second Github repo0:35
The TDD cycle3:21
Requirements1:10
Writing the first failing unit test5:33
Fake it till you make it2:54
Apply test-driven development by faking the validate function to pass tests, design the task validator api, and progress from red to green toward a real solution.
Triangulation3:59
Obvious implementation2:42
Explore TDD in action with AI through the red-green-refactor cycle, using failing tests, the obvious implementation, and triangulation to validate task transitions.
Task must be assigned to move to DONE2:50
Task must not be blocked to move to DONE2:51
Demonstrate a tdd cycle from red to green to refactor, add a failing test for blocked tasks that cannot move to done, and align code with the open closed principle.
Refactoring5:59
Task must not be already in DONE to move to DONE3:37
Wrap up3:02

Section intro0:46
Apply a real world test driven development approach to build a task manager with a restful API, in-memory persistence, mocks, and functional tests guiding design.
The Outside-In TDD cycle1:48
Task manager requirements0:35
Writing the first failing functional test4:55
User API first failing unit test3:19
Making the test compile3:22
Set up domain and api structure, define a user service interface with a create function, and implement a user data class (id, username, password) for the test compile.
Making the test pass1:31
Practice test-driven development by invoking the user service's create method with a username and password, handling exceptions with try-catch, returning proper status codes, logging failures, and validating that tests pass.
Completing the user API3:26
The functional tests as a north star2:08
User service first failing unit test3:01
Completing the user service2:34
Implementing the user repository and completing the user registration feature4:43
Writing a failing functional test for the task creation feature3:34
Task API first failing unit test4:19
Making the test compile2:41
Completing the task API4:22
Finding the next step1:27
Follow the test driven development cycle to identify the next implementation point by running a failing functional test, then implement the task service and handle an unsupported operation exception.
Task service first failing unit test3:47
Completing the task service5:02
Execute the happy-path for creating a new task by mocking the user repository, running the task service, and asserting a single save call with a valid task.
Enhancing the user repository3:21
Completing the task creation feature2:56
Writing a failing functional test for the task status update feature3:56
Writing a failing unit test for the task API4:37
Completing the task API2:23
Making the test pass and adding a second unit test to the task API4:42
Injecting the task validation logic to the task service6:04
Execute the functional test, observe a failure, and implement update status in the task service by adding a validation package with a task transition validator.
Adding a second test to the task service and making it pass3:19
Completing the task service3:20
Completing the task status update feature2:54
Wrap up2:21

Section intro1:12
Writing a failing functional test for the my tasks feature4:38
Writing the failing unit tests for the task API4:04
Making them pass and writing the failing unit tests for the task service4:26
Demonstrate test-driven development with AI to implement the task service, writing failing tests, implementing get tasks by assignee, and handling repository methods with unsupported operations.
Making them pass and writing the failing tests for the task repository2:40
Making them pass and completing the my tasks feature1:12
Wrap up1:30

Requirements

No prior experience with TDD is required.
A basic understanding of Kotlin, Spock, and Spring Boot is helpful, but not mandatory. The course focuses on core testing principles and development methodologies, using these technologies as a medium — not the main subject. You’ll pick up what you need along the way.

Description

Test-Driven Development in Action with AI - Nikos Voulgaris.

Apply Test-Driven Development in real-world software, integrate AI tools into your workflow, and elevate your professional skills.

Does Test-Driven Development sound fun and promising, but feel limited to toy examples like Tic-Tac-Toe or FizzBuzz?

I've been there. It was frustrating to see such a powerful technique presented in ways that felt disconnected from the complexities of real-world software. That's why I created this course - to help software engineers confidently apply TDD in production codebases, and discover its full potential beyond the basics.

In this course, I share the hard-earned lessons from my own journey mastering TDD - distilled into a practical, structured, and accessible format. You'll learn how to build maintainable systems from the ground up, and how to integrate AI tools into your development workflow to move faster without sacrificing control or the benefits of TDD.

By the end of the course, my goal is for you to walk away with real-world, hands-on skills, a deeper understanding of TDD - and hopefully, to have enjoyed the ride.

What You'll Build

Throughout the course, we’ll build a task manager application that exposes a RESTful API. Users will be able to register, create tasks, update task statuses, and retrieve their tasks.

We’ll follow the principles of hexagonal architecture - not dogmatically, but by letting it emerge naturally through our TDD process. To keep things simple, we’ll use in-memory persistence.

Technologies used: Spring Boot, Kotlin, and Spock. No prior in-depth knowledge of these tools is required. The focus isn’t on specific technologies - it’s on mastering the methodology, mindset, and discipline of Test-Driven Development.

You’ll also learn how to thoughtfully integrate AI tools to support (not replace) your decision-making and enhance your TDD workflow.

Why Learn From Me?

I'm a software engineer with over 12 years of professional experience. I started exploring TDD around a decade ago, and have been using it extensively in production for the past 8 years. Along the way, I've helped dozens of engineers adopt TDD through in-person coaching, pair programming, and online workshops.

I know the pitfalls, the resistance, the confusion - and the "aha" moments that make it all click. I created this course to pass those insights on to you.

Who this course is for:

Software engineers who understand TDD basics but struggle to apply it in real-world projects
Junior developers who want to learn how to build maintainable applications from scratch using Test-Driven Development
Mid-level engineers aiming to level up their skills and take a more structured, professional approach to development
Senior engineers who want to incorporate TDD into their toolkit and lead by example in their teams
TDD enthusiasts who enjoy exploring advanced use cases, nuanced trade-offs, and deeper insights into the methodology

TDD in Action with AI: From Fundamentals to Production

What you'll learn

Explore related topics

Course content

Introduction3 lectures • 4min

Unit Testing Fundamentals16 lectures • 42min

Classicist Test-Driven Development13 lectures • 39min

Outside-In Test-Driven Development30 lectures • 1hr 37min

Comparison of the two Test-Driven Development styles6 lectures • 9min

Test-Driven Development with AI7 lectures • 20min

Congratulations3 lectures • 1min

Requirements

Description

Who this course is for: