Writing atomic code is harder, but here is an example of a case where it will pay off significantly:

update :add_ten_to_score do
  change fn changeset, _ -> 
    Ash.Changeset.change_attribute(changeset, :score, changeset.data.score + 10)
  end
end

The action above raises an error about it not being atomic. In this case, the effect here is that if you ran this same update concurrently on the same record, it’s possible to have inconsistent results.

i.e with a record that has a score of 0
Action 1: record is read, current score: 0
Action 2: record is read, current score: 0
Action 1: new score is determined, new score 10
Action 2: new score is determined, new score 10
Action 1: data is written, new score 10
Action 2: data is written, new score 10

So now even though the action was called twice, and you’d expect a new score of 20, you actually have a new score of 10.

By using an action like this:

update :add_ten_to_score do
  change atomic_update(:score, expr(score + 10))
  # or use the built in
  change increment(:score, amount: 10)
end

you now have a fully atomic update that does not have the same problems as described above

I’ve made some tweaks to the atomic update docs to potentially help with clarity. Update Actions — ash v3.29.3

I think you are not an ash framework user.
You don’t get what “not that simple” means.

Just one use of manage_relationship makes action not able to be atomic.
And manage_relationship is a basic feature in ash,
which is for creating two related resources in one action.