在二十年前，你可能当作项目管理就是写厚厚的甘特图，要么靠午后的咖啡把需求改得面目全非。

那时候的“铁三角”——需求方、开发、测试——别看听起来像个铁三角，但大家心里都有数，各自按自己的节奏走。

那时候的沟通往往是线性的：你发个需求，我画个图，你改个用例，我提个 Bug。

要是这流程跑得顺畅，事件就办完了；要是卡住了，大家就启动嘟囔效率低，要么认定“你们哪位也不听”。

那时候的迭代就是好办的版本升级，要么发个 1.1 补丁，要么干脆直接跳过到 2.0。

那时候的毛病率高达 85%，要么功能没出来就炸了，要么用户用起来恨不得把屏幕砸了。

那时候的项目管理更像是一个中间商赚差价的地方，总有一个总负责人在拼命协调各方利益，大家拼尽全力，却往往输在最少了标准的那块地方。

那时候的文档就是用来应付老板看的，要是老板看了看不懂，那这份文档就废了，哪怕上面全是精美的图表。

那时候的 DevOps 还是那个意思，只有当它变得比改需求还关键时，大家才会启动注意。

那时候的 Agile 就是一个口号，挂在一个海报上，真正干活的时候大家还是按部就班地走流程。

那时候的测试就是最终把关，一旦发现 Bug 大家就启动骂，哪位也别想翻身。

那时候的透明度和敏捷性是两个彻底独立的概念，一个要求代码开源，一个要求团队像人一样沟通。

那时候的协作工具就是微信群，消息发出去就了，三天后你才知道有人回了你，就连根本没回，你就当作他不回，结局三天后他又回来了，又没回。

那时候的项目管理，说白了就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

那时候的交付物就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了，哪怕你是在用最好的工具。

那时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

那时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也没想到数据错了是大家一起写的。

那时候的 DevOps，就是当它启动让团队受益时，大家才启动看重起来，想让它变得更好。

那时候的透明度，就是代码公开后，大家才启动关切质量和效率，想让它变得更好。

那时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

那时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。

那时候的交付，就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

那时候的敏捷，就是大家一起切蛋糕，边切边改。

那时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责。

那时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

那时候的透明度，就是代码公开后，大家才启动关切质量和效率。

那时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

那时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。 把项目管理变成一个真正需求思索的领域，并不意味着要推翻所有老旧的价值观，而是要把那些被旧时代淘汰的垃圾数据扔进垃圾桶。

那会儿，我们总当作只要流程跑得通，难题自然就解决了。

这有个大毛病，就是好办陷入“流程陷阱”。你画了个完美的流程图，把它印在墙上，然后指望大家照着做。结局呢，流程跑起来后，流程本身就成了新的障碍。大家启动为了走流程而走流程，原本能直接做的活，被绕了八圈。

这时候的文档，就不再是沟通的桥梁，而变成了新的“第二层需求”。

更有甚者，大家会为了知足流程的形式主义，在数据上搞啥“里程碑”，在汇报上搞啥“幻灯片”，结局真的数据被埋起来了。

这就像是在泥地里建塔，塔越高，越好办倒。

这时候的项目管理，就不再是为了“把事件做完”，而是变成了“把事件做得像做工程那样”。便大家启动关切每一个细小的环节，就连把“优雅”当作了唯一的标准。

这时候的交付，不再是价值的传递，而是对现状的讽刺。

这时候的透明度和敏捷性，不再是两个独立的概念，而是变成了互相牵制的死结。想要透明，就务必开源；想要敏捷，就务必频繁变动。结局就是代码烂得像石头，需求改成了鬼话。

这时候的协作，不再只是工具的堆砌，而是变成了互相推诿的战场。大家都在嘟囔工具不好用，但没人愿意花工夫去优化它。

这时候的项目管理，就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

这时候的交付物，就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

这时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

这时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

这时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

这时候的透明度，就是代码公开后，大家才启动关切质量和效率。

这时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

这时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。在二十年前，你可能当作项目管理就是写厚厚的甘特图，要么靠午后的咖啡把需求改得面目全非。

那时候的“铁三角”别看听起来像个铁三角，但大家心里都有数，各自按自己的节奏走。

那时候的沟通往往是线性的：你发个需求，我画个图，你改个用例，我提个 Bug。

要是这流程跑得顺畅，事件就办完了；要是卡住了，大家就启动嘟囔效率低，要么认定“你们哪位也不听”。

那时候的迭代就是好办的版本升级，要么发个 1.1 补丁，要么干脆直接跳过到 2.0。

那时候的毛病率高达 85%，要么功能没出来就炸了，要么用户用起来恨不得把屏幕砸了。

那时候的项目管理更像是一个中间商赚差价的地方，总有一个总负责人在拼命协调各方利益，大家拼尽全力，却往往输在最少了标准的那块地方。

那时候的文档就是用来应付老板看的，要是老板看了看不懂，那这份文档就废了，哪怕上面全是精美的图表。

那时候的 DevOps 还是那个意思，只有当它变得比改需求还关键时，大家才会启动注意。

那时候的透明度和敏捷性是两个彻底独立的概念，一个要求代码开源，一个要求团队像人一样沟通。

那时候的协作工具就是微信群，消息发出去就了，三天后你才知道有人回了你，就连根本没回，你就当作他不回，结局三天后他又回来了，又没回。

那时候的项目管理，说白了就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

那时候的交付物就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。 把项目管理变成一个真正需求思索的领域，并不意味着要推翻所有老旧的价值观，而是要把那些被旧时代淘汰的垃圾数据扔进垃圾桶。

那会儿，我们总当作只要流程跑得通，难题自然就解决了。

这有个大毛病，就是好办陷入“流程陷阱”。你画了个完美的流程图，把它印在墙上，然后指望大家照着做。结局呢，流程跑起来后，流程本身就成了新的障碍。大家启动为了走流程而走流程，原本能直接做的活，被绕了八圈。

这时候的文档，就不再是沟通的桥梁，而变成了新的“第二层需求”。

更有甚者，大家会为了知足流程的形式主义，在数据上搞啥“里程碑”，在汇报上搞啥“幻灯片”，结局真的数据被埋起来了。

这就像是在泥地里建塔，塔越高，越好办倒。

这时候的项目管理，就不再是为了“把事件做完”，而是变成了“把事件做得像做工程那样”。便大家启动关切每一个细小的环节，就连把“优雅”当作了唯一的标准。

这时候的交付，不再是价值的传递，而是对现状的讽刺。

这时候的透明度和敏捷性，不再是两个独立的概念，而是变成了互相牵制的死结。想要透明，就务必开源；想要敏捷，就务必频繁变动。结局就是代码烂得像石头，需求改成了鬼话。

这时候的协作，不再只是工具的堆砌，而是变成了互相推诿的战场。大家都在嘟囔工具不好用，但没人愿意花工夫去优化它。

这时候的项目管理，就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

这时候的交付物，就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

这时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

这时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

这时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

这时候的透明度，就是代码公开后，大家才启动关切质量和效率。

这时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

这时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。 在二十年前，你可能当作项目管理就是写厚厚的甘特图，要么靠午后的咖啡把需求改得面目全非。

那时候的“铁三角”别看听起来像个铁三角，但大家心里都有数，各自按自己的节奏走。

那时候的沟通往往是线性的：你发个需求，我画个图，你改个用例，我提个 Bug。

要是这流程跑得顺畅，事件就办完了；要是卡住了，大家就启动嘟囔效率低，要么认定“你们哪位也不听”。

那时候的迭代就是好办的版本升级，要么发个 1.1 补丁，要么干脆直接跳过到 2.0。

那时候的毛病率高达 85%，要么功能没出来就炸了，要么用户用起来恨不得把屏幕砸了。

那时候的项目管理更像是一个中间商赚差价的地方，总有一个总负责人在拼命协调各方利益，大家拼尽全力，却往往输在最少了标准的那块地方。

那时候的文档就是用来应付老板看的，要是老板看了看不懂，那这份文档就废了，哪怕上面全是精美的图表。

那时候的 DevOps 还是那个意思，只有当它变得比改需求还关键时，大家才会启动注意。

那时候的透明度和敏捷性是两个彻底独立的概念，一个要求代码开源，一个要求团队像人一样沟通。

那时候的协作工具就是微信群，消息发出去就了，三天后你才知道有人回了你，就连根本没回，你就当作他不回，结局三天后他又回来了，又没回。

那时候的项目管理，说白了就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

那时候的交付物就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

那时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

那时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

那时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

那时候的透明度，就是代码公开后，大家才启动关切质量和效率。

那时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

那时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。 把项目管理变成一个真正需求思索的领域，并不意味着要推翻所有老旧的价值观，而是要把那些被旧时代淘汰的垃圾数据扔进垃圾桶。

那会儿，我们总当作只要流程跑得通，难题自然就解决了。

这有个大毛病，就是好办陷入“流程陷阱”。你画了个完美的流程图，把它印在墙上，然后指望大家照着做。结局呢，流程跑起来后，流程本身就成了新的障碍。大家启动为了走流程而走流程，原本能直接做的活，被绕了八圈。

这时候的文档，就不再是沟通的桥梁，而变成了新的“第二层需求”。

更有甚者，大家会为了知足流程的形式主义，在数据上搞啥“里程碑”，在汇报上搞啥“幻灯片”，结局真的数据被埋起来了。

这就像是在泥地里建塔，塔越高，越好办倒。

这时候的项目管理，就不再是为了“把事件做完”，而是变成了“把事件做得像做工程那样”。便大家启动关切每一个细小的环节，就连把“优雅”当作了唯一的标准。

这时候的交付，不再是价值的传递，而是对现状的讽刺。

这时候的透明度和敏捷性，不再是两个独立的概念，而是变成了互相牵制的死结。想要透明，就务必开源；想要敏捷，就务必频繁变动。结局就是代码烂得像石头，需求改成了鬼话。

这时候的协作，不再只是工具的堆砌，而是变成了互相推诿的战场。大家都在嘟囔工具不好用，但没人愿意花工夫去优化它。

这时候的项目管理，就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

这时候的交付物，就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

这时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

这时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

这时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

这时候的透明度，就是代码公开后，大家才启动关切质量和效率。

这时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

这时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。 在二十年前，你可能当作项目管理就是写厚厚的甘特图，要么靠午后的咖啡把需求改得面目全非。

那时候的“铁三角”别看听起来像个铁三角，但大家心里都有数，各自按自己的节奏走。

那时候的沟通往往是线性的：你发个需求，我画个图，你改个用例，我提个 Bug。

要是这流程跑得顺畅，事件就办完了；要是卡住了，大家就启动嘟囔效率低，要么认定“你们哪位也不听”。

那时候的迭代就是好办的版本升级，要么发个 1.1 补丁，要么干脆直接跳过到 2.0。

那时候的毛病率高达 85%，要么功能没出来就炸了，要么用户用起来恨不得把屏幕砸了。

那时候的项目管理更像是一个中间商赚差价的地方，总有一个总负责人在拼命协调各方利益，大家拼尽全力，却往往输在最少了标准的那块地方。

那时候的文档就是用来应付老板看的，要是老板看了看不懂，那这份文档就废了，哪怕上面全是精美的图表。

那时候的 DevOps 还是那个意思，只有当它变得比改需求还关键时，大家才会启动注意。

那时候的透明度和敏捷性是两个彻底独立的概念，一个要求代码开源，一个要求团队像人一样沟通。

那时候的协作工具就是微信群，消息发出去就了，三天后你才知道有人回了你，就连根本没回，你就当作他不回，结局三天后他又回来了，又没回。

那时候的项目管理，说白了就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

那时候的交付物就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

那时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

那时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

那时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

那时候的透明度，就是代码公开后，大家才启动关切质量和效率。

那时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

那时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。 把项目管理变成一个真正需求思索的领域，并不意味着要推翻所有老旧的价值观，而是要把那些被旧时代淘汰的垃圾数据扔进垃圾桶。

那会儿，我们总当作只要流程跑得通，难题自然就解决了。

这有个大毛病，就是好办陷入“流程陷阱”。你画了个完美的流程图，把它印在墙上，然后指望大家照着做。结局呢，流程跑起来后，流程本身就成了新的障碍。大家启动为了走流程而走流程，原本能直接做的活，被绕了八圈。

这时候的文档，就不再是沟通的桥梁，而变成了新的“第二层需求”。

更有甚者，大家会为了知足流程的形式主义，在数据上搞啥“里程碑”，在汇报上搞啥“幻灯片”，结局真的数据被埋起来了。

这就像是在泥地里建塔，塔越高，越好办倒。

这时候的项目管理，就不再是为了“把事件做完”，而是变成了“把事件做得像做工程那样”。便大家启动关切每一个细小的环节，就连把“优雅”当作了唯一的标准。

这时候的交付，不再是价值的传递，而是对现状的讽刺。

这时候的透明度和敏捷性，不再是两个独立的概念，而是变成了互相牵制的死结。想要透明，就务必开源；想要敏捷，就务必频繁变动。结局就是代码烂得像石头，需求改成了鬼话。

这时候的协作，不再只是工具的堆砌，而是变成了互相推诿的战场。大家都在嘟囔工具不好用，但没人愿意花工夫去优化它。

这时候的项目管理，就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

这时候的交付物，就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

这时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

这时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

这时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

这时候的透明度，就是代码公开后，大家才启动关切质量和效率。

这时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

这时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。 在二十年前，你可能当作项目管理就是写厚厚的甘特图，要么靠午后的咖啡把需求改得面目全非。

那时候的“铁三角”别看听起来像个铁三角，但大家心里都有数，各自按自己的节奏走。

那时候的沟通往往是线性的：你发个需求，我画个图，你改个用例，我提个 Bug。

要是这流程跑得顺畅，事件就办完了；要是卡住了，大家就启动嘟囔效率低，要么认定“你们哪位也不听”。

那时候的迭代就是好办的版本升级，要么发个 1.1 补丁，要么干脆直接跳过到 2.0。

那时候的毛病率高达 85%，要么功能没出来就炸了，要么用户用起来恨不得把屏幕砸了。

那时候的项目管理更像是一个中间商赚差价的地方，总有一个总负责人在拼命协调各方利益，大家拼尽全力，却往往输在最少了标准的那块地方。

那时候的文档就是用来应付老板看的，要是老板看了看不懂，那这份文档就废了，哪怕上面全是精美的图表。

那时候的 DevOps 还是那个意思，只有当它变得比改需求还关键时，大家才会启动注意。

那时候的透明度和敏捷性是两个彻底独立的概念，一个要求代码开源，一个要求团队像人一样沟通。

那时候的协作工具就是微信群，消息发出去就了，三天后你才知道有人回了你，就连根本没回，你就当作他不回，结局三天后他又回来了，又没回。

那时候的项目管理，说白了就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

那时候的交付物就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

那时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

那时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

那时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

那时候的透明度，就是代码公开后，大家才启动关切质量和效率。

那时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

那时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。 把项目管理变成一个真正需求思索的领域，并不意味着要推翻所有老旧的价值观，而是要把那些被旧时代淘汰的垃圾数据扔进垃圾桶。

那会儿，我们总当作只要流程跑得通，难题自然就解决了。

这有个大毛病，就是好办陷入“流程陷阱”。你画了个完美的流程图，把它印在墙上，然后指望大家照着做。结局呢，流程跑起来后，流程本身就成了新的障碍。大家启动为了走流程而走流程，原本能直接做的活，被绕了八圈。

这时候的文档，就不再是沟通的桥梁，而变成了新的“第二层需求”。

更有甚者，大家会为了知足流程的形式主义，在数据上搞啥“里程碑”，在汇报上搞啥“幻灯片”，结局真的数据被埋起来了。

这就像是在泥地里建塔，塔越高，越好办倒。

这时候的项目管理，就不再是为了“把事件做完”，而是变成了“把事件做得像做工程那样”。便大家启动关切每一个细小的环节，就连把“优雅”当作了唯一的标准。

这时候的交付，不再是价值的传递，而是对现状的讽刺。

这时候的透明度和敏捷性，不再是两个独立的概念，而是变成了互相牵制的死结。想要透明，就务必开源；想要敏捷，就务必频繁变动。结局就是代码烂得像石头，需求改成了鬼话。

这时候的协作，不再只是工具的堆砌，而是变成了互相推诿的战场。大家都在嘟囔工具不好用，但没人愿意花工夫去优化它。

这时候的项目管理，就是大家拿着放大镜找茬，把好办的 Bug 都挑得面目狰狞，却没人愿意承认自己搞砸了。

这时候的交付物，就是对着老板汇报，要是老板认定“不错”，那项目就修好吧；要是老板认定“不合格”，那项目就烂了。

这时候的敏捷开发，就是大家坐在一起，拿着白板，把需求像切蛋糕一样一张张切下来，边切边改。

这时候的测试，就是大家一起盯着代码跑，一旦发现数据不对，大家就启动互相指责，哪位也别想翻身。

这时候的 DevOps，就是当它启动让团队受益时，大家才启动看重。

这时候的透明度，就是代码公开后，大家才启动关切质量和效率。

这时候的协作，就是当大家发现沟通成本忒高时，才启动意识到工具的关键性。

这时候的项目管理，就是大家拼尽全力，却往往出于少了标准，害得过程混乱，结局糟糕。