Hey Tom,

Going the controller route would definitely be more involve. You would have to ensure the layout looks the same. Also, handling batches is another story. For example, if edits are enabled in the the list layout view, you would have to override that as well. Also it would not check edits through the API, lets say Excel Connector.

So it depends the situation and what your users want. If it is just a convenience thing through the New or Edit page, then the controller would be a better option. I can go into more detail if that does sound like what you want.

However, if your trigger is working, you may not want to deal with it. I do have some suggestions on your code though, if you want them. They are typically good coding practices but not necessary. They may also help the speed up your code. Which for cloud computing is never a bad thing and the littlest speed enhancements can matter. Also, how much did you test this? I can see some areas in your code for potential bugs/ I'll try to point them out.

You check isInsert a lot in your code. Why not just have one check in the beginning. This way you don't have to check for each time when it is not dependent on the record. The trigger will either be before insert, or before update. Some of your other checks can be minimized as well. For example, in the second loop, I believe it will be put in the oppMap when opp.Name is not null unless oppName != System.Trigger.oldMap.get(op.Id).Name. I don't even know why you do this check. Who cares about the old values of Name. It should be sufficient just to check if the new names are duplicates. Because what if they are swapping two names? Then you would get an error. Unless that what you want.

I see your comment says you don't want to touch names that have not been changed. Well, if it hasn't been changed it will still get added to the oppMap. Then if another record tries to give it that same name, it will throw an error because you checked the oppMap, which the other name was already added.

Also, you create a bunch of variables in your loop. I don't know if apex optimizes and reuses them, but if it doesn't, then you are wasting time allocating those variables everytime when you don't need too. 

Here are some of the changes I mean. 

trigger OppDupCheck_AutoCreateOppName on Opportunity (before insert, before update) {
    //*********************************************************
    //
    // Checks for duplicates and auto populates opp name field
    // with account name + mm/yy from the effective date
    //
    //*********************************************************
    // Create a unique set of Account ids we will be querying
    Set<Id> accIds = new Set<Id>();
    // Create a map to store the Account ID's and Names
    Map<Id, Account> accounts;
    Map<String, Opportunity> OppMap = new Map<String, Opportunity>();
    
    if (Trigger.isInsert){
        for(Opportunity opp :Trigger.new){
            // Save this Account ID - we will need it later
            accIds.add(opp.AccountId);
        }
        // Query the Account table to get all the accounts associated with the Opportunity(s)
        accounts = new Map<id, Account>([SELECT Id, Name FROM Account WHERE Id in :accIds]);    } 
    
        String currentName;     
        Integer currentLength;           
        String fmtDate;
        for (Opportunity opp :Trigger.new) { 
            currentName = opp.Name;      
            currentLength = currentName.length();           
            string fmtDate = DateTime.newInstance( opp.Effective_Date__c.year(), 
                    opp.Effective_Date__c.month(), 1, 0, 0, 0).format('MM/yy'); 
                                
            //currentName = accounts.get(opp.AccountId).Name;           
            if (currentName == '*' || currentLength <= 3){
                // user did not enter at least three characters for an opportunity name
                // It is assumed that we will auto populate the currentName with opp.Account
                // and append the mm/yy.               
                currentName = currentName + ' ' + fmtDate;
            } else {
                // User must have typed there own opp.Name 
                // Let us see if they include mm/yy
                if (currentName.substring(currentLength - 3,currentLength - 2) <> '/') {
                                            
                    // We need to append the mm/yy because the user did not include it                 
                    currentName = currentName + ' ' + fmtDate;
                }                        
            } 
            opp.Name = currentName;

            // make sure we do not treat an opportunity name
            // that is not changing during an update as a dup
            // make sure another new opportunity is not also a dup
            if (opp.Dup_Name_Checker__c)
               if (opp.Name != null && oppMap.containsKey(opp.Name)) {
                   opp.Name.addError('Another new Opportunity has the same Name.');
               } else {
                   oppMap.put(opp.Name, opp);
               }  
            }      
        }              
    }
        
    // using a single database query, find all the opportunities in
    // the database that have the same name as any of the opportunities
    // being inserted or updated.
    for (Opportunity opp : 
       [SELECT Dup_Name_Checker__c, Name FROM Opportunity WHERE Name in :oppMap.keySet()]) {
        if (opp.Dup_Name_Checker__c) {     
            oppMap.get(opp.Name).Name.addError('A Opportunity with this Name already exists.');
        }
    }

}

So make sure I didn't mess up any of your code. I took out things I thought was unnecessay but they could have been.

You don't even have to bother making any of these changes, just thought I share :)