Forem: Lucian Ghinda

Good Enough Testing Workshop

Lucian Ghinda — Wed, 08 Oct 2025 19:21:37 +0000

There are still some spot available for Good Enough Testing Workshop this Friday at 15:00 UTC.

Here are all the details about the workshop. In case you have questions reply here or via email -> hello@goodenoughtesting.com

During the workshop, I use Ruby code to demonstrate logic that facilitates discussion of various testing techniques. However, knowing Ruby is not a strict requirement.

The code samples resemble pseudocode, thanks to Ruby's remarkable similarity to English.

Example:

During the workshop, we will not write any test code in RSpec or Minitest; instead, we will focus more on test design.

Here is an example of a slide from the workshop where we discuss test design for low risk and low effort. We also cover high risk and high effort scenarios.

If you want to participate register here: https://goodenoughtesting.com/learn/good-enough-testing-workshop

LLM: removing a test because it cannot make it pass

Lucian Ghinda — Wed, 08 Oct 2025 12:56:32 +0000

During the workshop on reliable test case generation using LLMs that I delivered at EuRuKo, I talked about the importance of staying in control for effective testing.

Without it, LLMs might do things like this: After several attempts to pass a test, the option becomes simply to remove it. 🤔

A personal newsletter

Lucian Ghinda — Fri, 03 Oct 2025 11:37:53 +0000

I launched a personal newsletter at newsletter.lucianghinda.com

This morning, I sent my first email.

Why start this newsletter? I had newsletters set up in multiple places, and managing them became challenging. I want to focus on writing.

What will you find inside?
Mostly the same content I share on social media: Ruby, Rails, Testing, Creativity, and tech-related topics that I find interesting and worth sharing.
If you enjoy my content here, you'll appreciate what you find there.

This isn't a replacement for the Short Ruby Newsletter, which will continue as usual. My personal newsletter is about my interests, passions, and writings, all related to Ruby, Rails, and tech.

In the Short Ruby Newsletter, my role is as a curator, ensuring we include what's essential for the Ruby community. In my personal newsletter, I can focus on what I personally enjoy and find intriguing, while also compiling my writings from various sources.

Here is an example of the first edition: https://newsletter.lucianghinda.com/p/welcome-to-my-personal-newsletter-a144

Everyone Tests Now But Are We Testing the Right Things?

Lucian Ghinda — Thu, 02 Oct 2025 16:18:15 +0000

Over the last 15 years, many companies phased out QA teams.

The idea: everyone is responsible for quality.

That pushed developers to write more tests, and tooling improved a lot.

But here’s the catch: high coverage doesn’t always mean high quality.

Coverage Isn’t Enough

Let’s take a simple example:

class User < ApplicationRecord
  def initials
    name.scan(/\b\w/).join
  end
end

With one test you can hit 100% coverage. Add a second for a negative case, and you’re done… right?

Not really.
If the name is José Ángel, this method only returns J.
If it’s 佐藤陽翔, it returns nothing.

Coverage reports look perfect. The user experience does not.

What’s Missing: Test Design

When QA teams disappeared, we lost something important: structured test design.

Most of us never formally learned it—we picked up “write some unit tests” or “learn a framework.”

But test design is about asking bigger questions:

What really matters for the user?
Which risks are worth testing for?
Which cases are most important to cover systematically?

Without that, testing becomes a numbers game: just write more tests.

Good testing isn’t about more tests. It’s about the right tests.
And that’s a skill every developer can (and should) learn.

👉 This is a shortened version of a longer article where I go deeper into:

How QA teams vanished
Why developers need testing skills
Practical starting points for learning test design

Read the full article here at https://goodenoughtesting.com/articles/what-we-lost-when-qa-teams-dissapeared

Ruby San Francisco Scene is heating up

Lucian Ghinda — Thu, 02 Oct 2025 10:50:35 +0000

San Francisco Ruby scene is heating up

Source: https://sfruby.com

Already two events planned for this year:

SF Ruby AI Hackathon happened in 19 July - https://lu.ma/znhcct7v?tk=17VJ2z
San Francisco Ruby Conference - 19-20 November - https://sfruby.com

And of course let's not forget about Monthly Ruby Meetups -> https://lu.ma/sfruby, next one being on 30th June.

Huge props to Irina Nazarova and the team there.

They are doing fantastic work to build up the Ruby scene in San Francisco!

Ruby Triathlon starts this week

Lucian Ghinda — Tue, 02 Sep 2025 10:01:30 +0000

The #Ruby Triathlon starts this week!

1️⃣ The first conference is Rails World, taking place in Amsterdam, Netherlands, on September 4–5. This event typically features many announcements about the future of #Rails.

I'm particularly curious about the Rails at Scale day and the open discussions. I hope many attendees will share ideas from those sessions.

The tickets are sold out! For those attending, enjoy the conference.

2️⃣ Next up is Friendly.rb, happening in Bucharest, Romania, on September 10-11, which is next week.

Friendly.rb is a small, friendly, and inspiring conference. We (yes, I'm one of the co-organizers) have lined up great speakers and a range of special events around the conference. Enjoy a brew-your-own-coffee corner to taste locally roasted beans, an outdoor trip to the Carpathian Mountains, a walkable city center tour, the Friendly Gameshow, and much more.

I'm looking forward to the mix of deep technical presentations about Ruby and Ruby on Rails, combined with talks on AI, SaaS, marketing, and freelancing.

Tickets are still available at friendlyrb.com

3️⃣ The third event is EuRuKo, taking place in Viana do Castelo, Portugal, on September 18-19.

This conference has been running since 2003, making it 22 years old, and it is arguably the biggest #Ruby conference in Europe. This year features a mix of AI, Ruby talks, Rails talks, and workshops. I will be delivering a workshop on using AI to generate tests.

Tickets are still available 2025.euruko.org

Flaky Tests, Courtesy of AI

Lucian Ghinda — Sat, 23 Aug 2025 09:08:05 +0000

When AI is writing tests in agentic mode, it's crucial to monitor its output.
Sometimes, it uses tricks to pass the tests or creates unnecessary tests.

Diff from a change made by an agentic LLM:

For example, consider this diff that has at least two issues:

The test is unnecessary for a medium-risk, medium-impact feature. It merely checks that the counter cache in Rails functions correctly. This test was written in an earlier iteration that I haven't reviewed yet.
The Category model has the following constraint:

index_categories_on_position_and_parent_id (position, parent_id) UNIQUE

Notice how it added a position: rand(1..1000) to make some tests to pass because they lacked the position?

This approach is just inviting flaky tests!

I added this to my Flakiness section:

- Use consistent data across tests to avoid flakiness. Prefer existing fixtures instead of generating data randomly.
- Do not use `rand` or anything similar when generating data for tests.
- Use `travel_to` for all time-sensitive tests (assert time or need time to make the test work)
- Use `.sort` when the results are not guaranteed to be in a specific order.

New AI Testing Workshop at EuRuKo 2025

Lucian Ghinda — Fri, 22 Aug 2025 15:42:21 +0000

I started working on the workshop for EuRuKo 2025, "Don't Let Your AI Guess: Teach It to Test."

The goal of this workshop is to introduce techniques for prompting that reduce the hallucinations AI may experience when asked to write tests.

This is intended for individuals using AI to enhance their coding, allowing them to remain in control of which changes are applied. It's likely unsuitable for fully agentic coding (unsupervised) unless you plan to use these prompts as system instructions for your agent.

Let me start with my core belief: current LLMs are NOT ready to independently write tests that achieve the following goals:

Verify requirements
Ensure the software behaves predictably and consistently over time
Specify current behavior

They can generate unit tests that pass by examining the code, whether you or they wrote it. While this is useful, it seems like merely documenting the current code behavior. Without supervision, it's just creating more tests to confirm the code works as it is written.
This resembles verifying requirements, but it is NOT! Verifying requirements involves writing tests based on expected behavior, not on the current business logic in the code. The surse of truth (called test oracle) for a test should be the product requirements, the users needs and the customer expectations and not the code.

If you care about correctness, consider using AI to generate tests, but maintain control:

Select which tests the AI will write
Review the test data
Review the assertions

Otherwise, you might end up with tests that pass but don't effectively test what's important, leaving your users unprotected from potential bugs.

I plan to do a dry-run of this workshop before the conference and if you want to get invited at a discounted price join the GoodEnoughTesting newsletter.

Invisible work separates friction from flow.

Lucian Ghinda — Thu, 21 Aug 2025 10:18:39 +0000

Quote from Jony Ive about quality
No one will thank you for good error messages or default states, but they will feel it!
The difference between friction and flow is invisible work.

This is also true for the development process:
Sloppy names turn into messy objects and interfaces. Messy objects lead to slower teams.

The same goes for testing: Be careful about how you organise the code inside the test files because if it gets messy, it will slow down the development and debugging in the future.

It all compounds.

Details are never just details! If you are using AI to generate code, make sure it generates good names in your domain.

Two new Ruby podcasts from Rails Foundation and Ruby Central

Lucian Ghinda — Wed, 20 Aug 2025 13:12:46 +0000

In case you missed this in the last period, there are two new podcasts in #Ruby world:

On Rails - a podcast produced by the Rails Foundation and hosted by Robby Russell

👇

https://onrails.buzzsprout.com

Ruby Gems Podcast produced by Ruby Central and hosted by David Hill and Marty Haught
👇
https://www.buzzsprout.com/2509083

PS: Both of them are hosted https://www.buzzsprout.com/ - built also with Ruby on Rails

Remember to set the frequency for replication to Litestream!

Lucian Ghinda — Tue, 19 Aug 2025 08:07:52 +0000

Curious about how I ended up with an invoice nearing $100 for conducting over 20 million Class A operations on Cloudflare R2?

I initiated several Litestream processes across a variety of side projects and forgot to set the sync interval! :) It defaults to 1s

The backup I was handling was more complex than the main production database. It included slight variations in the SQLite file because it automatically queried various external services to check the status of different entities.

Just add:

sync-interval: 4h

to the replica section.

Here is a full example:

dbs:
  - path: /mnt/goodenoughtesting/current/storage/production.sqlite3
    replicas:
      - type: s3
        bucket: $GOOD_ENOUGH_TESTING_BACKUP
        path: production
        access-key-id: $LITESTREAM_ACCESS_KEY_ID
        secret-access-key: $LITESTREAM_SECRET_ACCESS_KEY
        endpoint: $LITESTREAM_REPLICA_ENDPOINT
        region: auto
        sync-interval: 4h

Day 3 of why to join Friendly.rb Conference

Lucian Ghinda — Thu, 14 Aug 2025 13:33:38 +0000

I posted already about:

Now let's discuss the venue and why you should join Friendly.rb Ruby Conference 2025.

The event is happening in Romania at the Apollo111 Theatre, right in the city center. This location offers a genuine theater experience. Each year I've attended, the artistic atmosphere and history of creative expression in that room have left me feeling both relaxed and incredibly inspired to contribute more to my projects and the community.

I believe #Ruby stands out as a programming language that brings artistry to coding. We often talk about beautiful code and taste, making this venue a perfect fit for our conference.

Here are some pictures from the venue from last year:

The coffee area:

The conference room, looking at the stage:

More about coffee:

Bucharest boasts a vibrant coffee scene with numerous roasteries and excellent cafés. Check out my list of top coffee spots here: https://maps.app.goo.gl/jeMmvTNg6sqoeB7e7

I've also created a smaller list of great coffee shops near the FriendlyRB venue for your morning coffee run: https://maps.app.goo.gl/SJ8J1T9oZosQFuVq8

The Brew you own coffee corner

Buy your ticket at https://friendlyrb.com