I don't know about Go, but in Java and .NET world this is trivially solvable with libraries like MapStruct. If you have a model with 20 fields and need to create a tiny slice of it (with let's say three fields), you need a few lines of boilerplate: create a record with those fields (1-3 LOC):

  record Profile(int id, String login, boolean isAdmin) {}

  interface UserMapper {
    // arrays are just one example, plain models and plenty
    // of other data structures are supported
    Profile[] usersToProfiles(User[] user);

    // other mappers...
  }

  class UserController {
    //
    @GET("/profiles")
    Profile[] getUserProfiles() {
      var users = userRepo.getUsers();
      return userMapper.usersToProfiles(users);
    }
  }

It also handles nested/recursive entities, nulls, etc. It's also using codegen, not reflection, so performance is exactly the same as if you had written it by hand, and the code is easy to read.

https://mapstruct.org

Go developers usually "don't need these complications", so this is just another self-inflicted problem. Or maybe it's solved, look around.

Actually it's even easier in Go with struct embedding:

    type SmallerThing struct {
        Id     int
        Login  string
        IsAdmin bool
    }

    type UserController struct {
        SmallerThing
        OtherField  Whatever
        OtherField2 SomethingElse
    }

>you have a model with 20 fields and need to create a tiny slice of it (with let's say three fields), you need a few lines of boilerplate: create a record with those fields (1-3 LOC):

>create a mapper for it:

> ...

>Go developers usually "don't need these complications", so this is just another self-inflicted problem.

In Go:

  type DTO struct {
    A, B, C string
  }

  // copy the fields to the DTO
  return DTO{A: o.A, B: o.B, C: o.C}