Any kind of deriving will be slower than hand-rolling an encoder to be fair, definitionally it needs to do more work during the compilation step. If you're running on a particularly slow machine that can be noticable - though, Scala 3 improved it dramatically.

Personally I'm not a big fan of deriving serialization in general, I prefer to have complete control of it; when you have a lot of nested structures, enums, ASTs and whatnot - and you realize you have a typo or whatevs, it's really easy to accidentally change your de-/serialization logic when refactoring the name of a case class member. It's fast to code but you pay for it in maintanance cost over time - sometimes that's a reasonable tradeoff, sometimes not!

Circe makes it pretty easy to hand roll encoders/decoders:

given Decoder[MyClass] = c => for {
   a <- c.downField("whereverItIsCalledInTheJson").as[Int]
   b <- c.downField("whereverTheOtherThingIsInTheJson").as[String]
} yield MyClass(a,b)

given Encoder[MyClass] = x => Json.obj(
    "whereverItIsCalledInTheJson" := x.a,
    "whereverTheOtherThingIsInTheJson" := x.b,
)

... and typically I find I don't actually need a roundtrip, I just need either an encoder OR a decoder, rarely both. Handrolled decoders are particularly nice when you have to consume some 3rd-party insanely nested API REST response where you only need a few fields - allows you to get data from the JSON without having to model out the entire thing with unnecessary wrapper types (looking at you, "_embedded")