ash/documentation/topics/manual-actions.md

  All validation still takes place, but the `result` in any `after_action` callbacks
  attached to that action will simply be the record that was read from the database initially.
  For creates, the `result` will be `nil`, and you will be expected to handle the changeset in
  an after_action callback and return an instance of the record. This is a good way to prevent
  Ash from issuing an unnecessary update to the record, e.g updating the `updated_at` of the record
  when an action actually only involves modifying relating records.

  You could then handle the changeset automatically.

  For example:

  # in the action

  ```elixir
  action :special_create do
    manual? true
    change MyApp.DoCreate
  end

  # The change
  defmodule MyApp.DoCreate do
    use Ash.Resource.Change

    def change(changeset, _, _) do
      Ash.Changeset.after_action(changeset, fn changeset, _result ->
        # result will be `nil`, because this is a manual action

        result = do_something_that_creates_the_record(changeset)

        {:ok, result}
      end)
    end
  end
  ```

for manual reads

                Manual read actions will simply be handed the ash query and the data layer query.
                If you simply want to customize/intercept the query before it is sent to the data layer
                then use `modify_query` instead. Using them in conjunction can help ensure that calculations and aggregates
                are all correct. For example, you could modify the query to alter/replace the where clause/filter using
                `modify_query` which will affect which records calculations are returned for. Then you can customize how it is
                run using `manual`.

                ```elixir
                # in the resource
                actions do
                  read :action_name do
                    manual MyApp.ManualRead
                    # or `{MyApp.ManualRead, ...opts}`
                  end
                end

                # the implementation
                defmodule MyApp.ManualRead do
                  use Ash.Resource.ManualRead

                  def read(ash_query, ecto_query, _opts, _context) do
                    ...
                    {:ok, query_results} | {:error, error}
                  end
                end
                ```