If they won't listen to you, suggest they run a test.  For example, a simple
test would be create a table with an integer primary key with the identity
clause and insert some number of rows into it and and see how long it takes
and how much space the table takes up when you're done.  Then do the same
thing with a table using a varchar key with the scheme you outlined and see
how long that takes and how much space that table takes up.  For example,
for the identity column and 100,000 rows, I ran

Create Table TestInt (PK int identity Primary Key)
go
Declare @Time1 datetime
Declare @Time2 datetime
Declare @InsertCounter int
Set @InsertCounter = 1
Set @Time1 = Current_Timestamp
While @InsertCounter <= 100000
Begin
 Insert TestInt Default Values
 Set @InsertCounter = @InsertCounter + 1
End
Set @Time2 = Current_Timestamp
Select DateDiff(ms, @Time1, @Time2) As ElaspedMS
Exec sp_spaceused 'TestInt', 'True'

(I know that's not the fastest way to insert 100,000 rows, but since I
presume your real system will insert the rows one at a time, I had this test
do that also.)  This test on my machine took about 50 seconds, and the
sp_spaceused said reserved space was 1,352 KB, data 1,288 KB, index 16 KB
and unused 48 KB.

With the varchar key, it's more complicated.  You need a way to store the
next key (I added a table with one row), a way to compute the next key (I
have a stored proc, please note this should not be used in production, it's
not bullet proof at all, it doesn't for example, handle concurrent requests
for the next key).  But this is only a test, so I was keeping it simple.  So
that code was

Create Table TestVC (PK varchar(6) Primary Key)
Create Table NextVC (PK int Primary Key, NextVCPK varchar(6))
Insert NextVC (PK, NextVCPK) Values (1, '1')
go
Create Procedure GetNextKey @NextKey varchar(6) Output As
Begin
 Declare @NewNextKey varchar(6)
 Declare @CharToProcess tinyint
 Declare @CharAsciiValue tinyint
 Declare @Done tinyint
 Select @NextKey = NextVCPK From NextVC Where PK = 1
 Set @NewNextKey = @NextKey
 Set @CharToProcess = Len(@NewNextKey)
/* if value is all Z's, Z or ZZ or ZZZ, etc
 then next value is a 1 followed by the appropriate number of zeros */
 If @NewNextKey In ('Z', 'ZZ', 'ZZZ', 'ZZZZ', 'ZZZZZ')
 Begin
   Set @NewNextKey = '1' + Replicate('0', @CharToProcess)
 End
 Else
 Begin
   Set @Done = 0
   While @Done = 0
   Begin
     Set @CharAsciiValue = Ascii(Substring(@NewNextKey, @CharToProcess, 1))
     /* Find the next value for this character */
     Set @CharAsciiValue = Case
   /* change 0-8 to the next number, 9 to A, A-Y to Z and Z to 0 */
       When @CharAsciiValue Between 48 And 56 Then @CharAsciiValue + 1
       When @CharAsciiValue = 57 Then 65
       When @CharAsciiValue Between 65 And 89 Then @CharAsciiValue + 1
       Else 48 End
     Set @NewNextKey = Stuff(@NewNextKey, @CharToProcess, 1,
Char(@CharAsciiValue))
     If @CharAsciiValue <> 48 Set @Done = 1 /* we are done */
     Else Set @CharToProcess = @CharToProcess - 1
   End
 End
 Update NextVC Set NextVCPK = @NewNextKey Where PK = 1
End
go
Declare @Time1 datetime
Declare @Time2 datetime
Declare @InsertCounter int
Declare @NextKey varchar(6)
Set @InsertCounter = 1
Set @Time1 = Current_Timestamp
While @InsertCounter <= 100000
Begin
 Exec GetNextKey @NextKey Output
 Insert TestVC (PK) Values (@NextKey)
 Set @InsertCounter = @InsertCounter + 1
End
Set @Time2 = Current_Timestamp
Select DateDiff(ms, @Time1, @Time2) As ElaspedMS
Exec sp_spaceused 'TestVC', 'True'

This took about 120 seconds, and the sp_spaceused said reserved space was
2,568 KB, data 2,504 KB, index 16 KB and unused 48 KB.

So about twice as long to load the varchar keys, twice as much space, and
much more complicated coding.

Tom