I tend to use list assignment for most arguments:

my ($foo, $bar, @baz) = @_;
[download]

But if there are one or two arguments that are conceptually special, I'll use shift for them. (Or pop if it's the final argument, though that's less often the case.) For example, in OO code, the invocant:

sub some_method {
   my $self = shift;
   my ($foo, $bar, @baz) = @_;
  ...;
}
[download]

Or for an around modifier, then the original coderef and the invocant would both be special:

around some_method => sub {
   my ($orig, $self) = (shift, shift);
   my ($foo, $bar, @baz) = @_;
  ...;
};
[download]

Or if I was writing my own implementation of grep, then the coderef would be special enough:

sub mygrep {
   my $code = shift;
   my (@items) = @_;
  ...;
}
[download]

My reason for this is that it's often nice to have all the "normal" arguments remaining in @_ in case you need to pass them all through to another function that you're calling.

For single argument subroutines, I apply the same logic. If it's conceptually something like an invocant, I'll use shift; otherwise I'll use list assignment. After all, a single argument subroutine might end up taking more arguments as the project grows in complexity.