Let's begin!

AI

Why I stopped using AI code editors warns that overusing AI code editors can lead to a loss of technical intuition and fundamental engineering skills.

Writing code was never the bottleneck argues that writing code faster is a reasonable goal, but it doesn't eliminate the real bottlenecks. The author identifies some of these bottlenecks and describes how we can remove them with Claude Code and Github Actions.

AI Use at Work Is Causing "Brain Fry", Researchers Find, Especially Among High Performers explains that constant interaction with AI tools can lead to cognitive overload, fatigue, and slower decision-making.

How I Dropped Our Production Database and Now Pay 10% More for AWS is a post mortem of an incident where a Claude Code agent wiped the production AWS infrastructure (including the database) and deleted all automated backups.

The Software Development Lifecycle Is Dead argues that AI agents have collapsed the traditional software development lifecycle into a tight loop of intent, execution, and observation.

Every layer of review makes you 10x slower explains how every layer of approval drastically decreases our velocity, and argues that even though AI can generate code faster, the only way to sustainably increase velocity is to do fewer reviews.

AI Agent Hacks McKinsey: 5 Situations When You Should Not Deploy Agents identifies five situations where we shouldn't use AI agents.

AI won't make you rich. But fixing bugs in AI slopware will argues that debugging and stabilizing AI generated code will be the next big economic opportunity for developers.

If you thought the speed of writing code was your problem - you have bigger problems argues that if we increase the amount of generated code with AI without addressing the real bottlenecks, we will only create "traffic jams" which reduce the amount of delivered value.

AI Coding is Gambling describes how coding has changed from an act that requires thinking to a form of gambling where developers pull a slot machine for solutions, and argues that this process makes the development work less satisfactory.

AI Made Writing Code Easier. It Made Being an Engineer Harder. argues that AI tools have made code generation faster, but the software engineering role has become more taxing, and the AI tools have caused an identity crisis for developers who love writing code.

Anatomy of the .claude/ Folder provides a comprehensive tutorial to the contents of the .claude/ directory. For example, the author provides an introduction to commands, rules, skills, and agents.

Thoughts on slowing the fuck down warns that agentic code generation can create unrecoverable technical debt, and argues that we should slow down and put the developer back to the driver's seat.

AI Tools for Developers Are Not Enough explains that even though teams can generate code faster than ever before, this doesn't guarantee that they will solve the right problems. The author argues that if we want to build the right thing faster, we need AI tools which support the whole software development lifecycle.

Writing an agent skill explains how we can optimize Claude Code's token usage by writing agent skills.

Claude Code Template for Spring Boot introduces the author's Claude Code template for Spring Boot applications. This template leverages both agents and skills, and its goal is to help us to generate production ready Spring Boot applications.

Cloud

Bucketsquatting is (Finally) Dead defines the term 'bucketsquatting' and explains how AWS solved this issue by introducing account specific S3 namespaces.

Software Development

Nobody Gets Promoted for Simplicity argues that engineering culture often values over-engineering and ignores the value of simple solutions.

Things I miss about Spring Boot after switching to Go identifies six Spring Boot features the author misses and highlights three things Go does better.

XML is a Cheap DSL argues that XML is an effective tool for building domain-specific languages.

Start naming your useEffect functions, you will thank me later argues that naming useEffect functions makes our code cleaner and helps us to identify effects that shouldn't exist.

The junior developer pipeline is broken, and nobody has a plan to fix it explores the problems caused by the collapsing junior developer hiring pipeline and identifies solutions that could help us solve them.

GitHub Actions Is Slowly Killing Your Engineering Team compares GitHub Actions and Buildkite, and argues that we should use Buildkite instead of GitHub Actions.

JavaScript (No, Not That One): Modern Automation with Java highlights modern Java features that have transformed Java into a viable scripting language.

Don’t trust, verify explains why we should verify that the tools we use were released by the correct "source" and haven't been tampered with.

axios Compromised: npm Supply Chain Attack via Dependency Injection is a comprehensive analysis of the supply chain attack where the popular axios NPM package was used to deliver malware.

Post Mortem: axios npm supply chain compromise is the official post mortem of the axios supply chain attack.

Announcing grüt - A Terminal File Explorer with Git, GitHub, and AI Integration introduces a new terminal-based file explorer that works in Linux, MacOS, and Windows.

Java 26 Is Here, And With It a Solid Foundation for the Future summarizes the key changes and new features introduced in Java 26.

Feeling Left Behind in Tech? This Is Your 90-Day Comeback Plan introduces a structured 90-day strategy that helps experienced developers to modernize their skill sets.

Speed up Java Startup with Spring Boot and Project Leyden explains how we can achieve up to a 75% faster startup time for Spring Boot applications.

Managing Sensitive Data in jOOQ 3.21+ Logs describes how we can exclude sensitive data from jOOQ logs.

The post Software Development Monthly 3 / 2026 appeared first on Petri Kainulainen.

    

Let's begin!

Test Design

AI and Testing: Using Local Models for Testing demonstrates how we can use local AI models for generating test cases and Playwright tests.

Your API Tests Are Passing. That’s the Problem argues that a green API test suite can create a false sense security, especially, if our test suite contains so called shallow assertions.

Generating code faster is only valuable if you can validate every change introduces a testing strategy that helps us to ensure that rapid code generation won't introduce bugs.

The Testing Pyramid is a Relic. Here is What Actually Works. argues that the testing pyramid doesn't work when we are writing modern distributed systems, and introduces a testing strategy which concentrates on static analysis, integration tests, and observability.

Who Tests the Tests? AI, QA, and the Verification Paradox explains what "don't trust without verification" means if we generate automated tests with AI.

Backend

Writing tests with Claude Code - part 1 - initial results describes what the author learned when he used Claude Code for generating automated tests for a Spring Boot REST API.

UI / End-to-End

Why We Chose Playwright Over Cypress compares Playwright and Cypress, and explains why the author decided to use Playwright.

17 Playwright Testing Mistakes You Should Avoid helps us to write better Playwright tests by identifying 17 mistakes we shouldn't make.

Test IDs are an a11y smell explains why the author thinks that we shouldn't use data-testid and describes how we can write tests which don't require test ids.

Making Code Coverage Work with Playwright explains how we can generate code coverage reports for Playwright tests with @bgotink/playwright-coverage.

Your Tests Are Green. Your App Is Broken identifies a situation where our application is broken even though our tests pass, and provides one possible solution to this problem.

Introducing Angular Testing Library Zoneless introduces the new @testing-library/angular/zoneless subpackage which is basically q trimmed down version of the original Angular Testing Library.

The post Clean Test Automation Monthly 3 / 2026 appeared first on Petri Kainulainen.

   

Related Stories

• Clean Test Automation Monthly 3 / 2025
• Clean Test Automation Monthly 3 / 2024

 

Let's begin!

AI

AI Doesn’t Reduce Work — It Intensifies It argues that AI causes workload creep where employees will increase their workload until they start to suffer from cognitive fatigue and burnout.

Context Is Now a First-Class Architectural Concern explains that context is no longer just data. It's a critical concern that must be designed and limited so that we can ensure that using AI is economically viable.

Inside OpenAI’s in-house data agent describes how OpenAPI build an in-house data agent that allows their employees to query over 600 petabytes of internal data and reduces the time it takes to get answers to their questions.

Lines of Code Are Back (And It's Worse Than Before) argues that AI-assisted coding has revived the lines of code (LOC) as a primary metric of productivity and explains why LOC is still an awful way to measure productivity.

An AI Agent Published a Hit Piece on Me (Part 1, Part 2, Part 3, and Part 4) provides a detailed account of an incident where an AI agent published a hit piece against an open source developer who closed a pull request opened by the AI agent.

Who opened the door? covers an incident where an AI agent started a smear campaign against a developer and identifies a question that's not asked by anyone else.

AI fatigue is real and nobody talks about it argues that even though AI helps us to finish individual tasks faster, it increases the time (and mental energy) needed to coordinate AI agents and review the finished work.

Minions: Stripe’s one-shot, end-to-end coding agents Part 1 and Part 2 introduces homegrown and unattended AI agents which produce over a thousand merged pull request every week.

What AI coding costs you identifies the negative effects of overrelying on AI tools, and argues that we should find a balance between AI assisted coding and old fashioned manual coding.

A Message To Devs At The Frontier argues that developers should be curious and embrace the new opportunities instead of simply ignoring AI assisted engineering.

Two Flavors of Spec-Driven Development and Why I Clearly Prefer One introduces two interpretations of spec-driven development and explains why the author thinks that one of them is essential for building business-critical systems.

You don’t have to if you don’t want to is a long and an old-fashioned rant about generative AI.

Software Development

Java has evolved. Your code can too highlights 113 code snippets and allows us to compare the old and modern implementation side by side.

Farewell, Rust explains why the author started using Node.js instead of Rust when he is doing web development.

Turn Dependabot Off argues that we shouldn't use Dependabot and explains what we should do instead.

Code Isn’t Slowing Your Project Down, Communication Is explains that delays in large organizations are rarely caused by the complexity of the produced code and argues that these delays are caused by poor communication, unclear processes, and clashing priorities.

Building Modular Monoliths With Kotlin and Spring explains why we should consider building modular monoliths and describes how we can build them with Kotlin and Spring Modulith.

Migrating to Modular Monolith using Spring Modulith and IntelliJ IDEA describes how we can migrate from a traditional monolith to a modular monolith.

Sinks, Not Pipes: Software Architecture in the Age of AI introduces techniques that help us to deal with AI agents that lack the long-term memory humans use to navigate poorly structured code bases.

How I estimate work as a staff software engineer explains why estimating is hard, argues that an estimate is a political tool, and describes how the author estimates work.

Deadlines As An Act Of Love argues that a deadline isn't an attempt to control employees. Instead, deadlines help us to schedule our work and support (or not to support) each other's objectives.

The post Software Development Monthly 2 / 2026 appeared first on Petri Kainulainen.

    

Let's begin!

Test Design

How to Keep Your Smoke Testing Useful argues that we should keep our smoke test suite as small (and fast) as possible and concentrate on testing things that matter.

The Big TDD Misunderstanding argues that we should write our tests from the user's perspective and provides four tips that help us to write good tests.

A Field Guide to Not Overengineering Test Automation describes how we can avoid writing an over-engineered test framework that requires more maintenance than our application.

When you outsource testing to the AI, you lose the ability to understand your system explains that if we outsource testing to AI, we will loose our mental model of the application because we don't get the understanding that's traditionally gained by writing tests and reading code.

Why AI won't save your Flaky Tests argues that if we use AI for fixing flaky tests, we will only hide the architectural issues which cause our tests to fail randomly.

Lessons I Wish I Knew When I Started in Test Automation identifies five lessons the author would have wanted to learn sooner.

Refactoring the RestAssured.Net code with Claude Code describes how the author used Claude Code to refactor the codebase of the RestAssured.Net project and explains what the author learned from this experiment.

Backend

Why We Should Not Mock Collections With Mockito explains why we should use real collections instead of mock objects when we are writing tests for code that uses collections (this a good advice for model objects as well).

Data Driven API Testing in Java with Rest-Assured and TestNG: Part 1, Part 2, Part 3, Part 4, and Part 5 describes how we can write data-driven tests with Rest Assured and TestNG (use the friend link if you don't have a Medium account).

UI / End-to-End

How I solved SMTP Timeouts with Mailpit and JavaMail explains how the author solved a DNS resolution issue which caused test failures when the system under test tried to send an email to localhost.

Testing Error Boundaries by Breaking Contracts, Not Code argues that we should test our frontend applications by intercepting successful API responses and injecting "contract violations" (such as missing fields or unexpected data types). This helps us to ensure that our UI degrades gracefully instead of crashing.

Using agent skills to write Playwright tests describes how the author generates end-to-end tests by leveraging AI agents.

The post Clean Test Automation Monthly 2 / 2026 appeared first on Petri Kainulainen.

   

Related Stories

• Clean Test Automation Monthly 2 / 2025
• Clean Test Automation Monthly 2 / 2024

 

Let's begin!

AI

We’re not concerned enough about the future of junior-level software engineering explains that because AI has basically removed the need for junior developers, companies will be in serious trouble when the current senior developers and architects retire because there won't be people who can replace them.

The John Henry Problem - Why Racing Against AI is a Losing Game argues that developers who compete with an AI are winning a race that doesn't matter.

Don't fall into the anti-AI hype argues that developers shouldn't ignore AI because of moral reasons and recommends that every developer should test these new AI tools and see if they are helpful for them.

The 80% Problem in Agentic Coding explains that even though AI can generate "most of the code" quite easily, generating "the rest" is a lot more challenging.

Spring AI Agentic Patterns Part 1, Part 2, Part 3, Part 4, and Part 5 is a series of blog posts which highlights the features of the spring-ai-agent-utils toolkit that provides agentic patterns for Spring AI.

Some thoughts about using AI-Coding tools argues that while AI tools can generate decent code, they don't necessarily increase the productivity of an experienced developer.

Stepping into Crazy AI World argues that developers should pretty much ignore AI hype and concentrate on learning how they can use AI tools for delivering software faster than ever before.

Software Development

Software craftsmanship is dead argues that software development projects tend to favor speed and short-term metrics over writing high-quality and maintainable code.

21 Lessons From 14 Years at Google identifies the software development lessons gathered from 14 years at Google.

How Dependabot Actually Works describes how Dependabot identifies the required dependency updates and creates PRs.

The Next Two Years of Software Engineering identifies five crucial questions that will define software engineering for the next two years.

YAML? That’s Norway problem is an interesting and funny post which explains why the country code NO is parsed as false.

Why Senior Engineers Let Bad Projects Fail explains that sometimes the most "senior" move is to stay silent and let a flawed project fail.

Make It Make Sense argues that massive failures happen when the meaning of data or UI is left implicit.

Checked exceptions and lambdas identifies three different approaches which help us to use checked exceptions with lambdas.

What’s New in Maven 4 highlights the key features of Maven 4.

Towards faster builds describes how the Quarkus team improved the build time of Quarkus applications when they got feedback that the build time was noticeably higher than the build time of a similar Spring Boot application.

Software Design Principles That Matter identifies three software design principles which help us to build flexible and maintainable code.

Spring Boot Debugging – Now Remote describes how we can debug a remote Spring Boot application with IntelliJ Idea.

Data-Oriented Programming for Java: Beyond Records introduces the next phase of data-oriented programming for the Java programming language: carrier classes and interfaces.

The post Software Development Monthly 1 / 2026 appeared first on Petri Kainulainen.

    

Let's begin!

Test Design

AI-generated tests as ceremony argues that if we use AI to generate tests after writing our code, we reduce testing to a hollow ceremony and miss the opportunity to see the tests fail before they pass.

Buying the Right Test Coverage (With a Deductible) suggests that we should treat automated tests as an economic trade-off and write only the tests which have an acceptable return of investment.

Back to the basics: Rethinking how we use AI in testing argues that AI should be used to support, not replace, human expertise and domain knowledge.

Testing for Quality, Betting on Value explains that even though testing can verify if a product works, it cannot ensure that we have built the right thing.

Stop Chasing 100% Coverage: A Pragmatic Frontend Testing Pyramid argues that we should concentrate on writing the correct tests instead of chasing the 100% test coverage.

Automation Is Not Quality, And Never Was explains why automated tests don't help us to create "quality".

Designing API Test Coverage for Microservices argues that we shouldn't rely on high test coverage percentages. Instead, we should select the required test cases by doing risk-based prioritization.

Flaky Tests: a journey to beat them all defines the term flaky test and identifies three methods the author used to eliminate them.

The Thing Everyone Misses About Tests argues that writing tests helps us to become better engineers.

Backend

Rethinking Spring Application Integration Testing argues that Spring integration tests should shift from traditional horizontal slicing to vertical and functional slices.

How to Execute Tests Selectively in TestNG explores multiple strategies for re-running failed TestNG tests.

Revolutionizing Integration Testing with TestContainers: A Modern Enterprise Approach explains how we can use Testcontainers for running "real" external services which are used by the system under test.

Custom JUnit 5 Extensions for Testing explains how we can simplify our test suites by writing custom JUnit 5 extensions.

Testing Emails with Testcontainers and Mailpit describes how we can write end-to-end tests for code that sends emails.

Introduction to Behavior Driving Development with Java and MongoDB describes how we can write BDD tests for MongoDB repositories with Java and Cucumber.

UI / End-to-End

Automating Push Notification Testing with Appium describes how we can write tests which ensure that push notifications are sent and received correctly.

The post Clean Test Automation Monthly 1 / 2026 appeared first on Petri Kainulainen.

   

Related Stories

• Clean Test Automation Monthly 1 / 2025
• Clean Test Automation Monthly 1 / 2024

 

Let's begin!

AI

Does AI make engineers more productive? It’s complicated argues that even though AI helps us to write code faster, it may not improve overall productivity.

The Specification Renaissance? Skills and Mindset for Spec-Driven Development argues that as AI-generated code becomes more common, our ability to write clear specifications that define what we want to build becomes the new bottleneck.

My 2026 Coding Stack highlights the author's AI coding stack for 2026. The author's goal is to maintain flexibility and avoid being locked into a single provider.

From Autocomplete to Co-Author: My Year with AI reflects on a year of using AI and explains how AI evolved from a simple autocomplete tool to a co-author which generates code that requires minimal changes.

On insight debt argues that if we concentrate on shipping features without understanding why they work, we take "insight debt" that makes our code hard to change.

Make your PR process resilient to AI slop argues that AI-generated code isn't a problem as long as we have a proper code review process.

AI Coding Tools Are Not the Problem, Lack of Accountability Is argues that the issue with AI-generated code is the lack of accountability when developers ship code without understanding and reviewing it.

2025: The year in LLMs summarizes the AI breakthroughs of 2025, and highlights the shift toward reasoning models and autonomous agents.

Software Development

A Central Conflict in 'Readable' Code argues that if we want to make our code simpler, we must be ready to make it less familiar (temporarily).

gRPC in Spring Boot describes how we can use the Spring gRPC project for implementing gRPC endpoints and explains how we can write a gPRC client that invokes our new endpoints.

API Versioning in Spring identifies five strategies for implementing API versioning in a Spring Boot web application.

Next level Kotlin support in Spring Boot 4 describes how Spring Boot 4 makes our life easier when we are writing Spring Boot applications with Kotlin.

The Ultimate Guide to Successfully Adopting Kotlin in a Java-Dominated Environment introduces a five-part tutorial that helps Java developers to adopt Kotlin. This tutorial addresses both technical and organizational challenges which we might face during this transition.

The best way to use the Spring @Transactional annotation provides a quick introduction to the @Transactional annotation and describes how the author uses it to configure transaction boundaries.

A Philosophy of Software Design vs Clean Code documents the debate between Robert "Uncle Bob" Martin and John Ousterhout on what's the best way to write clean code.

Logging sucks. And here's how to make it better explains why traditional logging sucks, and describes how we can solve this problem and make our logs useful again.

CS Books I'll be reading in 2026 highlights five books the author will read in 2026.

Write code that you can understand when you get paged at 2am argues that if we want to prevent on-call disasters, we must prioritize simple and readable code over "clever" abstractions which are impossible to understand in the middle of the night.

The Case Against Microservices argues that for most organizations, the drawbacks of micro services outweigh their benefits when compared to a well-structured monolith.

The post Software Development Monthly 12 / 2025 appeared first on Petri Kainulainen.

   

Related Stories

• Software Development Monthly 11 / 2025
• Clean Test Automation Monthly 3 / 2026
• Software Development Monthly 2 / 2026

 

Let's begin!

Test Design

Method-Based Approach for Readable E2E Tests Without Cucumber argues that using a properly named test method can be a better choice than using a BDD tool such as Cucumber.

Less, but better argues that we should focus more on doing things better and less on doing more things faster.

The Fallacy of Example-Based Testing argues that traditional example-based testing gives us a false sense of security and suggests two alternative techniques which help us to catch more bugs.

The AI Efficiency Trap: Why I Built a Tool to Tell Cursor What to Test explains how AI can generate many tests that boost code coverage statistics and ignore complex use cases because the code is "too hard to test". Thus, the author decided to write a pytest plugin which helps the AI agent to write more comprehensive tests.

On getting started with mutation testing provides a nice high-level introduction to mutation testing.

Backend

Introduction to Testing Micronaut With JUnit 5 describes how we can write our first automated tests for a Micronaut application with JUnit Jupiter.

A Guide to @ClassTemplate in Junit 5 explains how we can run a test class multiple times with different configurations.

Stepping down as maintainer after 10 years identifies three main reasons why Tim van der Lippe is stepping down as the maintainer of Mockito (there is a Reddit discussion about this as well).

Conditionally Ignore Tests in TestNG describes two different methods that allow us to programmatically ignore or run a test with TestNG.

UI / End-to-End

Playwright Pro Tip: Stop Digging! Auto-Attach API Request/Response Data to Your HTML Reports explains how we can attach HTTP request and response data to our Playwright test reports.

Turn Your Playwright Traces Into Living Test Documentation describes how we can use Playwright traces for generating a test documentation that's always up-to-date.

5 Essential cURL Commands for API Testing introduces five cURL commands which make API testing much easier.

Building a Custom API Assertion Library on Top of Playwright describes how we can write reusable assertions that help us to build a robust test suite that's easy read, write, and maintain.

The post Clean Test Automation Monthly 12 / 2025 appeared first on Petri Kainulainen.

   

Related Stories

• Clean Test Automation Monthly 2 / 2026
• Clean Test Automation Monthly 1 / 2026
• Clean Test Automation Monthly 3 / 2026

 

Let's begin!

AI

AI Assisted Engineering With an AI Chatbot - From Idea to Working Code is my own blog post which highlights six concrete success stories from my short AI assisted engineering journey.

LLMs are bullshitters. But that doesn't mean they're not useful explains why LLMs deliver the best results when they are used to assist an expert.

Vibe Coding: The Final Form of Hyper-Individualism provides an interesting take on vibe coding and the developers who practice it.

On AI Code Reviews describes the author's experiences on using Github Copilot for code reviews.

Cloud

I Took All My Projects Off the Cloud argues that using cloud makes no sense.

Cloudflare outage on November 18, 2025 is an honest postmortem of the Cloudflare outage which basically broke the internet.

Software Development

Don't sell to developers provides three tips which help us to sell our products to developers.

Architectural debt is not just technical debt argues that architectural debt spans every layer of an organization’s architecture and wrong decisions at the enterprise level can cause more damage than technical debt.

Business Value Gone Wild is a somewhat depressing blog post that explains what corporate life is like and why software built within large organizations often turns into a big ball of mud.

Null-Safe applications with Spring Boot 4 provides an introduction to the efforts which aim to reduce (or maybe even eliminate) the risk of NullPointerException in code bases which use Spring.

Don’t Refactor Like Uncle Bob (Second Edition) is a review of Uncle Bob's book Clean Code, 2nd Edition.

Arconia for Spring Boot Dev Services and Observability provides a quick introduction to Arconia which enhances the development experience and observability of Spring Boot applications.

Are you really wasting your time in Java without these 10 libraries? shares the author's opinion on 10 popular Java libraries.

On finding clients as an independent consultant identifies five ways a freelancer can find gigs even when the market has slowed down significantly.

What still fascinates me about software dev 15 years into my career identifies six things that still fascinate the author after 15 years in software development.

The post Software Development Monthly 11 / 2025 appeared first on Petri Kainulainen.

   

Related Stories

• Software Development Monthly 12 / 2025
• Clean Test Automation Monthly 3 / 2026
• Software Development Monthly 1 / 2026

 

Let's begin!

Test Design

What Makes a Test a Test? is a thought-provoking blog post which explains what an automated test truly is.

The Many Meanings of 'Test': From Experiment to Evaluation explains how the author transforms understanding into automated tests.

AI in Test Automation: What Actually Makes Sense (and What Doesn’t) introduces six use cases where using AI makes sense, identifies three situations where we shouldn't use AI, and gives tips that help us combine human logic with AI.

AI-Assisted Test Automation: Real-World Experience with Playwright Agents and GitHub Copilot shares the author's experiences using AI tools like Playwright AI Agents, GitHub Copilot, Cursor, and LLMs in their test automation workflow.

How I Approach Performance Testing for Modern APIs gives six tips that help us to build solid performance tests for modern APIs.

Why Your 97% Test Coverage Is a Lie explains why high test coverage doesn't guarantee that our code has no bugs and provides three tips that help us to write better automated tests.

From Test Pyramid to Christmas Tree is yet another blog post which argues that the test automation pyramid should be replaced with something else (this time with a Christmas tree).

"It’s Just A Flaky Test": The Most Expensive Lie in Engineering explains why ignoring flaky tests and rerunning the CI/CD pipeline is a costly mistake.

Backend

The best way to clean up test data with Spring and Hibernate describes why the author doesn't use @DataJpaTest and explains how he cleans up test data with Hibernate.

What’s New for Testing in Spring Boot 4 and Spring Framework 7 provides an overview of testing-related changes that were introduced in Spring Boot 4 and Spring Framework 7.

Introducing JUnit 6: What’s New and How to Test Kotlin Suspend Functions identifies the changes introduced in JUnit 6 and describes how we can write tests for Kotlin suspend functions with JUnit 6.

A Guide to Engine Test Kit in Junit 5 describes how we can run tests and track test execution statistics with Engine Test Kit.

Beyond the Happy Path: Synthetic Test Data in Java with Datafaker and Instancio explains why synthetic test data is better than hard coded test data and demonstrates how we can generate test data with Datafaker and Instancio.

UI / End-to-End

Authentication in Playwright: You Might Not Need Project Dependencies identifies the drawbacks of performing authentication in a setup project and introduces a better way to write tests that require authentication.

How Playwright Test Agents Are Changing the Game in E2E Automation provides a solid introduction to both the Playwright MCP server and test agents.

Sharding in Playwright: Speeding Up Your Test Suites and CI Pipelines explains how we can improve the performance of our Playwright tests by leveraging sharding.

The post Clean Test Automation Monthly 11 / 2025 appeared first on Petri Kainulainen.

   

Related Stories

• Clean Test Automation Monthly 3 / 2026
• Clean Test Automation Monthly 2 / 2026
• Software Development Monthly 1 / 2026