# The Cost-of-Change Curve Is Wrong (Here’s Why) ## Метаданные - **Канал:** Mountain Goat Software - **YouTube:** https://www.youtube.com/watch?v=X79ZeZFok_Q - **Дата:** 04.03.2026 - **Длительность:** 3:37 - **Просмотры:** 291 ## Описание The cost-of-change curve has shaped how software teams manage projects for decades. It suggests that the later a change happens in development, the more expensive it becomes. But in modern software development — especially with agile practices, automated testing, continuous integration, and AI-assisted development — that assumption no longer holds the way it once did. In this video, we explore why the traditional cost-of-change model from the 1970s and 1980s is increasingly outdated. Advances in tooling, agile practices, and now AI have dramatically reduced the cost and risk of modifying software later in the development process. But while the cost of writing and revising code has dropped, a new constraint has emerged: feedback delay. The real bottleneck in modern product development is no longer implementation — it's learning what to build and getting fast feedback from users. This shift has important implications for how leaders manage product teams. Many organizations still rely on approval processes and planning assumptions designed for a world where late changes were catastrophic. In reality, adaptability and fast learning now matter far more than perfect upfront requirements. If you're working with Agile, Scrum, product development, or AI-powered software teams, understanding this shift is critical. Subscribe for more insights on Agile leadership, product development, and modern software management. Learn more about agile training and coaching: https://www.mountaingoatsoftware.com Chapters 00:00 The Cost-of-Change Curve Explained 00:19 Why Late Changes Used to Be Expensive 01:04 How Agile Reduced the Cost of Change 01:23 Why AI Accelerates the Shift 02:06 The Real Cost of Change Today 02:36 What This Means for Managers 03:22 Adaptability Beats Accuracy ## Содержание ### [0:00](https://www.youtube.com/watch?v=X79ZeZFok_Q) The Cost-of-Change Curve Explained One of the most widely cited laws in software development isn't true anymore. The cost of change curve, it's outdated and most managers are still managing as if it isn't. For decades, we've believed that the later you make a change, the more expensive it becomes. That idea ### [0:19](https://www.youtube.com/watch?v=X79ZeZFok_Q&t=19s) Why Late Changes Used to Be Expensive came from Barry Beam's research in the 1970s and 80s. And at the time, it was absolutely right. Software was expensive. Tools were primitive. Testing was manual. Integration was painful. Deployment was risky. If you found a major requirement change late, you could be looking at months of redesign and retesting. Late change really was disastrous. But here's what we forgot. That curve was a snapshot, not a law of physics. And the economics of software has changed. Tools flattened the curves. Modular architectures flattened the curve. Automated testing flattened the curve. Then agile arrived. Agile didn't ### [1:04](https://www.youtube.com/watch?v=X79ZeZFok_Q&t=64s) How Agile Reduced the Cost of Change magically make change. It took advantage of what was already becoming true. Kent Beck captured this in the subtitle of his book, Extreme Programming Explained: Embrace Change. That wasn't motivational. It was economic. ### [1:23](https://www.youtube.com/watch?v=X79ZeZFok_Q&t=83s) Why AI Accelerates the Shift Now AI pushes this even further. AI flattens the cost of change curve even more. AI reduces the human time required to write and revise code. That sounds incremental. It isn't. When coding gets faster, experimentation gets cheaper. Trying an idea is cheaper. Revising it is cheaper. Starting over is cheaper. AI makes iteration inexpensive enough that the traditional fear of late change starts to disappear. And when that happens, the bottleneck shifts. The cost of change becomes less about writing code and more about waiting for feedback. The primary cost of change ### [2:06](https://www.youtube.com/watch?v=X79ZeZFok_Q&t=126s) The Real Cost of Change Today today is increasingly feedback delay, not development effort. This doesn't mean software development is easy. Understanding users is still hard. Discovery is still hard. Decision making is still hard. But the hard parts have moved. The hard part now is learning what to build. Once you have feedback, acting on it is cheaper than ever. That's the real shift. So what does this ### [2:36](https://www.youtube.com/watch?v=X79ZeZFok_Q&t=156s) What This Means for Managers mean for managers? Many organizations today still have approval processes designed for a world where late changes were catastrophic. In many companies, the slowest part of delivery isn't coding, it's waiting for permission. If the cost of change has fallen and AI is accelerating that decline, then the biggest risk isn't changing too late. The biggest risk is learning too late. Requirements don't need to be perfect. They need to be revisable. The cost of change curve hasn't disappeared. But if you still manage as if change is catastrophic, you're using a mental model that's decades out of date. In ### [3:22](https://www.youtube.com/watch?v=X79ZeZFok_Q&t=202s) Adaptability Beats Accuracy modern software development, especially in the age of AI, adaptability beats completeness of requirements. Stop trying to perfect requirements. Instead, perfect your feedback loop. --- *Источник: https://ekstraktznaniy.ru/video/46083*