If Customers Are The Developers or part of development in a piece of software... 

 -The software will hold on longer and will have less chance of becoming just a  
  temporary fling. 
 
 -The customers will feel more at home with the software. 
 
 -The customers play a part in adding more software features, not just the company or   dictator. 
 
 -The software can still have non-developer customers using the software as it is. 
 
 -The customers will be happier since they can modify what they need, as long as the
  software has enough open-ness or interface into it. Otherwise customers may
  complain about not enough customization, only some customization. 
 
 -The customers will be like a second staff, and will lessen development costs.
   Example: Joe Schmoe writes a plug-in for some software and offers it available to
            the public. It may have taken the software company 600 hours to write the
            plug in, but the customer did it for you. 
            Or with GnuLinux: Redhat uses software from Gnu, and Gnu is mainly built
            by customers using Redhat and other distros, so the customers are
            developers. It may have taken RedHat 600 hours to write one part of Gnu,
            but the customers did it for them. 
 
 -The software caters to developers and users, not just one alone. 
 
 -The software may be easier to narrow down bugs. The people using the software will
  be more technical and able to describe the bugs more precisely (assuming more 
  developers are using the software) 

Actual Examples:
---------------- 
 
 -Any software with a plug-in interface. 
 
 -Any software with an API interface. 
 
 -Internet Explorer with its plug-in side bars, panels, toolbars, API. 
   -i.e. Google Toolbar is useful, and is free. Yet it helps market the Windows OS
    at the same time. So customers are the developers, who are promoting his (Bill's)     software.
 
 -Opera with HTML side panels. Customers are developers, because they build panels
  for Opera. Which makes Opera a more successful browser.
 
 -Mozilla with plug in extensions 
 
 -All programming languages: Languages are what people use to build software. Create
  a language , and you will eventually have people using the language. So customers
  are your developers. (i.e. Microsoft with C#, Borland with ObjectPascal or 
  DelphiLanguage, Python and Guido, PHP and (...), Perl and Wall, Java and Sun, 
  JavaScript and Sun. 
 
 -Open-source/Closed-source hybrid software 
   i.e. OpenOffice and Mozilla as to StarOffice and Netscape. Customers are the
   developers, not because regular people use Netscape, but because
   DeveloperCustomers use Mozilla.
 
 -Photoshop with plug-ins 
 
 -Excel let's users create VBA scripts and excel macros. Therefore customers of MS
  Excel are in fact developers.
 
 -GnuLinux: RedHat, Mandrake, Slackware, Debian, etc., can each be a different distro 
  of GnuLinux, yet they still are Linux softwares. Customers are essentially the
  developers of GnuLinux.
 
 -Microsoft and the WinAPI . Let's people do anything they want with windows, while
  secretly marketing more windows software, due to the fact that the WinAPI based
  software must run on Windows OS. Without knowing the true source code behind
  windows, a developer can write software for windows. 
 
 -Microsoft with MicrosoftDotNet technology. Same as above. Except for the way that
  MicrosoftDotNet was engineered, this may make the situation worse, if GnuLinux can
  interpret DotNet on it's own OS. 
 
 -All open or free software. Customers develop and use the software.. essentially.
 
 -Open/Plug-in based combination based software. If the developer can write a quick
  plug-in without having to look over all the source code, this is an advantage.
 (plug-ins can still be useful in Open software too).