You might like to replace you inner while loop with:

$data->{$user}{$_} = shift @userdata for (@fields);
[download]

Okay, that's one part of my problem solved, thanks :)

Let me just work through that to make sure I have it....
It works from right to left, yes?
We iterate through each item in @fields, grabbing the associated item from @userdata, then assigning it to the hash, yes?

That's right. Note also that if there are too few fields in a line this simply assigns undef rather than generating an invalid access as your original code did.

If you are sure that the first line contains the header line then you can simply:

$_ = <DATA> or die "Empty file";
chomp;
# Throw away the first two fields (#, username) in the header
(undef, undef, @fields) = (split /\t/);
[download]

before the loop.

---

Perl is Huffman encoded by design.

#!/usr/bin/perl -w
use strict;
use Text::CSV_XS;
use IO::File;

my $csv = Text::CSV_XS->new({binary=>1,sep_char=>"\t"});
my $fh  = IO::File->new( 'hdi.csv') or die $!;
my $hash;
my $key_colnum = 0;
my $cols = $csv->getline($fh);
while(my $vals = $csv->getline($fh)){
  last unless @$vals;
  my %row;
  @row{@$cols} = @$vals;
  $hash->{ $row{ $cols->[$key_colnum] } } = \%row;
}
use Data::Dumper;
print Dumper $hash;
[download]

my $data = {};
use Text::CSV;
my $csv = Text::CSV->new();
open FILE, "foo.txt";                      # open a file
my $line = <FILE>;                         # get the header line
$line =~ s/^#//;                           # strip off leading #
$csv->parse($line);                        # parse line ...
my @cols = $csv->fields();                 #   ... storing column name
+s
while(my $line = <FILE>){                  # loop through rest of file
  $csv->parse($line);                      # parse line ...
  my @vals = $csv->fields();               #   ... getting the values
#  my %row = map { $cols[$_] => $vals[$_] } 0 .. $#cols;   # and hashi
+ng up based on col names
#  $data->{ $row{ $cols[0] } } = \%row;     # stick this hash into big
+ data structure.
                                           # NOTE:  it's hashing on th
+e first column..
                                           #  might want to change if 
+necessary
# UPDATE: just use a hash slice:
  @{ $data->{ $row{ $cols[0] } } }{ @cols } = @vals;

}
close FILE;                                # close file -- all done!
[download]

use Text::xSV;

my $parser = Text::xSV->new;
$parser->open_file( $datafile );

my @headers = $parser->read_header;
shift @headers; # Remove the # field.
my $user_header = shift @headers;

my $data;
while ( $parser->get_row ) {
    my $user = $parser->extract( $user_header );
    $data->{ $user }{ @headers } = [ $parser->extract( @headers ) ];
}
[download]

Update: Obviously, use tilly's corrections to my suggestion as he wrote the module in question. Plus, he's right. :-)

use Text::xSV;

my $parser = Text::xSV->new( filename=>$datafile, sep=>"\t" );
$parser->read_header;

my %data;
while (my $row_ref = $parser->get_row) {
    $data{ $row_ref->[1] } = $parser->extract_hash;
}
[download]

The significant changes from your version are:
1. xSV doesn't default to a tab. You have to tell it that you want that.
2. You don't need to call open_file - it will do that for you if you pass the filename into the constructor.
3. The return of read_header cannot be relied on, so don't rely on it.
4. I'm using the return of get_row directly. Yes, you can mix positional and name-based logic in Text::xSV.
5. Your slicing logic was buggy. But luckily there is no need to do something that complex.

UPDATE: A closer reading of the original question shows that the format differs from the obvious. The first row has an extra # in it that is not lined up with the other fields and needs to be discarded. Here is a solution to that variant:

use Text::xSV;

my $parser = Text::xSV->new( filename=>$datafile, sep=>"\t" );
my @headers = $parser->get_row;
shift @headers; # Get rid of the unwanted #
$parser->bind_fields(@headers);

my %data;
while (my $row_ref = $parser->get_row) {
    $data{ $row_ref->[1] } = $parser->extract_hash;
}
[download]

#!/usr/bin/perl -w
use strict;

my $datafile = "stuff.csv";
my @fields;
my $data;

open DATA, "<$datafile" or die "Could not open $datafile:$!\n";
#I handle the first line outside the loop
# Throw away the first two fields (#, username) in the header
# Are you sure about "first two?"
(undef, undef, @fields) = split /\t/, <>;

my ($user, @userdata);
while (<DATA>) {
    chomp();

    # If you're sure about the 2 fields above,
    # I think we need to drop the second field here too

    ($user, undef, @userdata) = split /\t/;
    @{$data->{$user}}{@fields} = @userdata;
}
close DATA;
[download]

#!/usr/bin/perl -w
use strict;

my $datafile = "stuff.csv";
my @fields;
my $data;

open DATA, "<$datafile" or die "Could not open $datafile:$!\n";
# Grab the first (header) line, discarding the first two fields
$_ = <DATA> or die "Empty file";
chomp((undef, undef, @fields) = (split /\t/));

# Grab the rest, and populate the hashref
while (<DATA>) {
    chomp();
    my ($user, @userdata) = (split /\t/);
    $data->{$user}{$_} = shift @userdata for (@fields);
}
close DATA;
[download]