One point he's making is that, especially for anything web-oriented, but for others as well, you benefit greatly by providing an open, programmable interface. That doesn't mean a UI with a macro language, but a UI that's mostly separate from the "engine" that does the real work -- and full, open documentation of how the UI talks to the engine, so anybody can write a whole new UI that uses the engine, add-ons to the engine that can hook seamlessly into your UI, etc.
In short, instead of building (or even thinking in terms of) complete products, you should think and work primarily in terms of producing useful components. Those components need to work with each other cleanly, but that's not enough by itself. The interfaces between those components need to be clearly documented and defined so they're suitable for essentially anybody to replace (for example) your UI with something of their own, plug it into your engine, and be able to use your engine to its full capabilities, because they have just as much access to its capabilities as anybody else does.
Ultimately, this isn't a dramatic change from what's been pushed for some time (e.g., 3-tier applications). The big difference is that even though they're written as components, most typical 3-tier applications still basically assume that all the components in use will be produced together, so all the interfaces between them are "private". In quite a few cases there are implicit assumptions that one component need not check inputs from another, because it "knows" what inputs the other can produce.
Especially for web-facing servers and such, that's just not tenable. Instead, every interface has to be "hardened" -- specified and implemented to work under any circumstances, specifically including the possibility that whatever's on the other side of the interface may be sloppy and crappy, or even a carefully engineered attacker.
Looked at from a slightly different perspective, a product should provide for entry at any of a number of different levels. For beginning users, it should have a polished UI. For more advanced users, it should have some sort of built-in programmability to tweak things they don't like, automate things they do too often, etc. Finally, and most importantly, it should provide a low-level interface that gives full control of every aspect of the "engine" of that product. This needs to be exactly what you use to develop your own code to work with the product's engine, so anybody else has just as complete of access to that engine as your own UI does.