Since the most fundamental program ever written it seems some architects and software developers feel the need to demonstrate, what they believe, is their superior software engineering skills by designing to an additional unspecified requirement. The unspecified requirement in question is complexity.
Complexity is not a design pattern to further ones career and I would argue that complexity is, in actuality, an anti-pattern in furthering ones career. As software engineers we should strive for simplicity and although it may not always be possible, we should ask ourselves if the level of complexity within the software we write is at an appropriate level and determine if refactoring the software could reduce the level of complexity.
Software should be written to be as simple as possible while still achieving the requirements for which the software is intended. It is especially true even if you consider yourself to be a guru developer in the particular language, technology, or platform to be used. This is because not everyone on the team, or everyone who will ever work on the team, will have the same skill level with that given language, technology, or platform.
If a system is written using the .NET framework, for example, the system should use the data access capabilities of ADO.NET or the presentation capabilities of ASP.NET. If someone was to write their own data access or presentation capabilities it will merely reduce the maintainability of that software. It would then be very doubtful that any business requirements existed that would necessitate such a deviation from those standard framework API's.
Are their occasions when writing your own version of an existing capability can be justified?
Yes there are, although you should always be able to provide justification in terms of business objectives for such a deviation from the standard capabilities provided within frameworks such as .NET or J2SE. Associated software development methodologies should also enforce the use of standard frameworks and provide a process by which appeals can be made to the architects and managers of a system on those occasions when a deviation is necessary to meet a business requirement. It is more likely, however, that the business requirement could be met by extending the existing framework capability rather than requiring an entirely new capability to be designed and written from scratch.
Wherever possible software should be written such that another developer, familiar only with the base technology (e.g. Microsoft .NET or J2SE etc.), would be able to rapidly become as effective as you if they were to join the team. Ideally this should be true without substantial assistance from those originally on the development team, and as such it is necessary to provide adequate documentation and code commenting when writing software based systems. Complexity therefore must be regarded as an anti-pattern and should be refactored out of software wherever possible.