I think I’d actually suggest not using a protocol-based encoder, primarily because with Ash resources you can have calculations/aggregates/metadata that you may want to display along with the resource. For instance, if you wanted to show related data, or if you wanted to show computed properties, you might want something like this:

def encode(resources, opts \\ []) do
  Jason.encode!(sanitize(resources, opts))
end

defp sanitize(records, opts) when is_list(resources) do
  Enum.map(records, &sanitize(&1, opts))
end

defp sanitize(%resource{} = record, opts) do
  if Ash.Resource.Info.resource?(resource) do
    fields = opts[:fields] || public_attributes(record)

    Map.new(fields, fn
      {field, further} ->
        {field, sanitize(Map.get(record, field), further)} 
      field -> 
        {field, sanitize(Map.get(record, field), [])} 
      end)
  else
    record
  end
end

defp sanitize(value, _), do: value

defp public_attributes(%resource{}), do: resource |> Ash.Resource.Info.public_attributes() |> Enum.map(&(&1.name))

Something like the above would let you call encode(record, fields: [:field1, :field2, relationship: [fields: [:field3]]).

This lets you load data and serialize it, i.e

MyResource
|> Ash.Query.load([:field1, :field2, relationship: [:field3]])
|> MyApi.read!()
|> Encoder.encode(fields: [:field1, :field2, relationship: [fields: [:field3]])