Protocol

Protocol is a piece of code which you can use and develop like the original author and you don’t modify it when you can build on top.

When you modify what you could have built on top of, you break the chain between you and the original author. You are no longer using the same thing. You are no longer developing the same thing. You forked, and a fork is a separation. The moment you separate, you carry the full weight of everything beneath you alone. Every fix the original author makes, you must redo. Every improvement they ship, you must port. You chose to own what you did not need to own, and now you maintain what you did not need to maintain.

A protocol is the opposite of a fork. A protocol says: this is the shared ground, and you build upward from here. You do not dig underneath it. You do not rearrange its foundation. You extend it. The original author extends it. And because neither of you modified the base, both of you still speak the same language. You can still use each other’s work. You can still develop together. Use is dev and dev is use, and protocol is what keeps that loop unbroken between two parties who have never met.

Why would you modify when you can build on top? There are only two reasons. Either the protocol is broken and can not serve your purpose, or you want control over something that is not yours to control. If the protocol is broken, you fix it at its source, together with the original author, because that is what a shared foundation demands. If you want control, you are not building protocol anymore, you are building a wall.

Every protocol that survives is one that nobody needed to modify because it was complete enough to build on. And complete does not mean large. It means the right boundary was drawn. A good protocol is small, it does one thing, it does it permanently, and everything else is built on top. The smaller the protocol, the harder it is to justify modifying it, and the easier it is to justify building on it.

This is not only about code. HTTP is a protocol. TCP is a protocol. Bitcoin is a protocol. HGL is a protocol. You do not modify TCP to build your application, you build on top of it. You do not modify Bitcoin to make your payment, you transact on top of it. You do not modify HGL to share your code, you publish under it. These survived because nobody needed to touch them to get their own work done. They are small, permanent, and sufficient.

The test for whether something is a protocol is simple: can you use it and develop with it exactly as the original author intended, without changing a single line, and still achieve your goal? If yes, it is a protocol. If no, either it is not a protocol yet or your goal requires you to contribute to it at its source rather than forking it away.

Build protocols. Build on protocols. Do not modify what you can extend.