Trust is a funny thing. You have it until you lose it and once it's lost its very hard to regain.

In terms of product development we have a couple of very sought after properties that share this “easier to lose than to gain”-aspect. The properties are innovation and intuitive design. At a deeper level these two properties are both close descendants of quality of ideas.

There is an all to familiar tale of small organizations who do innovative work, becomes successful, grows and in the process of growing loses the very properties that made the organization successful. This is followed by either turning into a soulsucking, profit hungering behemoth enterprise or organizational death. I think this tale is sad and unnecessary.

If we accept the premise that innovation and good idea cultivation isn’t done in crowds then the obvious conclusion must be that we want small teams. Once we accept that small teams are the ideal we must fundamentally shift our ideals from “let's make the work as parallel as we can” to “how do we make the individuals as productive as possible”

Many of today's software practices are fundamentally trying to decouple teams and software as much as possible (microservices i am looking at you). It almost seems like the ideal is everyone sitting in their own room, working on their own code and talking as little as possible to the rest of the organization. Do organizations really believe that this is a fertile bed for innovation and idea cultivation?

A second part of this puzzle is the use of tools that allow us to harness the fluidity of software. Most physical products are immutable. Once done with a product you must create a new one if changes are to be incorporated. You can't add rooms to a house that is already built. Or rather you can, but in most cases it is more economical to start over. Software is different though. There is no part of a piece of software that can’t be changed. Everything is fluid and subject to change. Furthermore it is generally much more economical to change an existing piece of software into something new instead of starting from scratch. That is ofcourse if you use the right tools.

Some software tools (like languages without good type systems) will put software back in the physical category (easier to start over than to change something existing).

Fortunately there exists tools that allow skilled programmers to refactor fearlessly and efficiently allowing for reuse at an unprecedented scale. This increase in reuse will also increase the productivity of individuals (sometimes by several hundred percent or more). As individuals become more productive this allows you cut down on the amount of or size of teams necessary to cover a product. This allows for ideas to flow more freely and allows the organization to unleash its innovative potential. But as already stated it all starts with being able to refactor existing code efficiently and fearlessly.