Big picture planning with pure Agile is extremely difficult. The first big problem is (as you've spotted) that pure Agile and forward planning (budgets, long-term timescales etc) fundamentally don't play well together.
If you are familiar with the project management triangle (scope, cost, timescale), Agile's focus is to fix cost and schedule and allow scope to be variable. In big organisations scope and timescale are often fixed (we need product X with these features by next quarter) and you then spend much of your time arguing the cost (i.e. number of developers) and often end up delivering late to boot because the timescale and permitted cost just were not enough.
This brings us onto the second issue - the change of mindset required to run pure Agile in a traditional company setting. The ideal advice would be get your organisation to buy into Agile wholesale and recognise that they can build a backlog of features but that not all of them may be delivered. However what is delivered will be high quality, on time and to a known cost. Changing to pure Agile can result in a serious shift of organisational thinking as Mike Cohen's book outlines expertly.
Unfortunately it's very very hard to change an entire organisation's thinking off the back of a single project so the third way is a compromise - you don't do pure Agile. What you do is something like RUP/Waterfall where you do some up front requirements analysis and do a bit of design and architecture work. Just enough to highlight risk areas and understand big-picture complexities. You then run an iteration "0".
Iteration 0 is proof of concept development for the high risk areas and to help understand key estimates and team performance. This may be a prototype that gets thrown away, it may be the foundations of your application's framework BUT the important point is to get a grounded feel for quality of estimates and likely velocity of the team etc. This gives you a foundation on which to build some plans and set a likely budget.
You can then run the dev work as normal Agile iterations, reaping the benefits of early user feedback and visibility etc. The iterative approach also helps provide regular milestones for you track against the plan, allow replanning points and earlier warning of budget over/under-runs. Use the estimates/actuals to date to re-work future plans as you go.
Don't do projects where the value is so low, that it isn't obvious that you are going to get a reasonable ROI.
Don't try to create fake certainty where there is none. The big picture planning is, and should be vague.
An agile implementation proces allows the customer to steer and adapt. If you have an experienced team, a well-known and stable domain, no new technology or methodology, you know its velocity. This also puts limits on the size of a project you can estimate. Teams change regularly, technology changes every few years.
If a customer needs a detailed budget, she needs to provide user stories to an estimatable level. That means a lot of work has to be done up-front. All visible risk spikes have to be done. That work is only worthwhile when the requirements are sufficiently stable.
The level of detail Eric J. describes is totally unneccessary. That should be in the software and extracted from it, instead of specified on paper beforehand.
[edit] Having a list of stories that are not understood sufficiently by customer or developer can be interesting. You should not spend a lot of time on them, as their stability is low. Using cart sorting, you can get a quick idea of size and priority. Everywhere where there are large position differences, you have a potential risk. Asking all stakeholders to provide new stories can help you estimate completeness.
When doing strategic planning, internal customers tend to care more about features that requirements.
I tend to create a feature roadmap using a tool that supports traceability (I prefer Enterprise Architect by Sparx Systems but many tools will do). I review the desired features and the order they are needed in at the project sponsor level.
Then, I work with appropriate individuals (sometimes business experts, business analysts, or senior IT folks such as architects) to break down each feature into a set of high level requirements. I create traceability from the high level requirements to the features. At this point, the requirements are often at the level of "Add an ABC screen", "Add a DEF screen", "Create a background process to recompute XYZ" and so forth, without further details. At this point, I work with appropriate people to estimate the effort for each high level requirement based on whatever metrics are available (ranging from gut feelings to statistics on how long e.g. screens take on average to add). My modeling tool then sums up the total estimated effort for each Feature, which can then be presented to the project sponsors and placed in a project plan.
Then we start an iteration to address the first Feature or Feature Set. Each high level requirement is refined into detailed requirements ("Screen ABC needs a First Name field, max length 40, required" and so forth). Depending on project needs, we may re-estimate effort for the more detailed requirements and roll them up to the high level requirement they trace back to. More commonly, a developer will be assigned to develop Screen ABC, will enter his own estimate in the sprint planning tool, and that estimate will roll back to the original model. Since the requirements he's implementing (and estimated) trace to the high level requirements, which trace to the feature level, the plan is constantly updated as we get into each iteration.
It requires some discipline and effort to set this up, but it is well worth it.
How to do big picture Agile? Think of it this way: The primary purpose of a business analyst in a Waterfall project is to come up with a minimal yet quality big picture of the essential behavioral requirements, and the primary purpose of a business analyst in an Agile project is to come up with a minimal yet quality big picture of the essential behavioral requirements.
发布评论
评论（5）
使用纯敏捷进行全局规划是极其困难的。第一个大问题是（正如您所发现的）纯粹的敏捷和前瞻性规划（预算、长期时间表等）从根本上不能很好地结合在一起。
如果您熟悉项目管理三角（范围、成本、时间尺度），那么敏捷的重点是固定成本和进度并允许范围可变。在大型组织中，范围和时间尺度通常是固定的（我们需要在下个季度之前提供具有这些功能的产品 X），然后您花费大量时间争论成本（即开发人员的数量），并且通常最终会因为时间尺度和时间而导致交付延迟。仅仅允许的成本是不够的。
这给我们带来了第二个问题——在传统公司环境中运行纯敏捷所需的思维方式的改变。理想的建议是让您的组织大规模购买敏捷，并认识到他们可以构建积压的功能，但并非所有功能都可以交付。然而，所交付的产品将是高质量、准时且成本已知的。正如Mike Cohen 的书专业地概述的那样，转向纯粹的敏捷可能会导致组织思维发生重大转变。
不幸的是，很难在单个项目的基础上改变整个组织的思维，所以第三种方法是一种妥协——你不做纯粹的敏捷。您所做的类似于 RUP/Waterfall，其中您进行一些前期需求分析并进行一些设计和架构工作。足以突出风险领域并了解总体复杂性。然后运行迭代“0”。
迭代 0 是高风险领域的概念开发验证，有助于了解关键估算和团队绩效。这可能是一个被丢弃的原型，它可能是应用程序框架的基础，但重要的是要对估计质量和团队可能的速度等有一个扎实的感觉。这为您提供了构建的基础一些计划并设定可能的预算。
然后，您可以像正常的敏捷迭代一样运行开发工作，获得早期用户反馈和可见性等的好处。迭代方法还有助于为您跟踪计划提供定期里程碑，允许重新规划点以及预算超额/不足的早期警告。运行。使用迄今为止的估计/实际情况来重新制定未来的计划。
Big picture planning with pure Agile is extremely difficult. The first big problem is (as you've spotted) that pure Agile and forward planning (budgets, long-term timescales etc) fundamentally don't play well together.
If you are familiar with the project management triangle (scope, cost, timescale), Agile's focus is to fix cost and schedule and allow scope to be variable. In big organisations scope and timescale are often fixed (we need product X with these features by next quarter) and you then spend much of your time arguing the cost (i.e. number of developers) and often end up delivering late to boot because the timescale and permitted cost just were not enough.
This brings us onto the second issue - the change of mindset required to run pure Agile in a traditional company setting. The ideal advice would be get your organisation to buy into Agile wholesale and recognise that they can build a backlog of features but that not all of them may be delivered. However what is delivered will be high quality, on time and to a known cost. Changing to pure Agile can result in a serious shift of organisational thinking as Mike Cohen's book outlines expertly.
Unfortunately it's very very hard to change an entire organisation's thinking off the back of a single project so the third way is a compromise - you don't do pure Agile. What you do is something like RUP/Waterfall where you do some up front requirements analysis and do a bit of design and architecture work. Just enough to highlight risk areas and understand big-picture complexities. You then run an iteration "0".
Iteration 0 is proof of concept development for the high risk areas and to help understand key estimates and team performance. This may be a prototype that gets thrown away, it may be the foundations of your application's framework BUT the important point is to get a grounded feel for quality of estimates and likely velocity of the team etc. This gives you a foundation on which to build some plans and set a likely budget.
You can then run the dev work as normal Agile iterations, reaping the benefits of early user feedback and visibility etc. The iterative approach also helps provide regular milestones for you track against the plan, allow replanning points and earlier warning of budget over/under-runs. Use the estimates/actuals to date to re-work future plans as you go.
不要做价值太低的项目，以至于您无法明显获得合理的投资回报率。
不要试图在没有确定性的情况下制造虚假的确定性。总体规划是而且应该是模糊的。
敏捷的实施过程允许客户引导和适应。如果你有一个经验丰富的团队，一个众所周知且稳定的领域，没有新技术或方法，你就知道它的速度。这也限制了您可以估计的项目规模。团队定期更换，技术每隔几年就会更换一次。
如果客户需要详细的预算，她需要提供可估计水平的用户故事。这意味着必须预先完成大量工作。所有可见的风险峰值都必须完成。只有当需求足够稳定时，这项工作才有意义。
Eric J. 描述的详细程度完全没有必要。这应该存在于软件中并从中提取，而不是事先在纸上指定。
[编辑] 列出客户或开发人员未充分理解的故事可能会很有趣。您不应该在它们上花费大量时间，因为它们的稳定性很低。使用购物车排序，您可以快速了解大小和优先级。凡是位置差异较大的地方，都有潜在的风险。
要求所有利益相关者提供新故事可以帮助您评估完整性。
Don't do projects where the value is so low, that it isn't obvious that you are going to get a reasonable ROI.
Don't try to create fake certainty where there is none. The big picture planning is, and should be vague.
An agile implementation proces allows the customer to steer and adapt. If you have an experienced team, a well-known and stable domain, no new technology or methodology, you know its velocity. This also puts limits on the size of a project you can estimate. Teams change regularly, technology changes every few years.
If a customer needs a detailed budget, she needs to provide user stories to an estimatable level. That means a lot of work has to be done up-front. All visible risk spikes have to be done. That work is only worthwhile when the requirements are sufficiently stable.
The level of detail Eric J. describes is totally unneccessary. That should be in the software and extracted from it, instead of specified on paper beforehand.
[edit] Having a list of stories that are not understood sufficiently by customer or developer can be interesting. You should not spend a lot of time on them, as their stability is low. Using cart sorting, you can get a quick idea of size and priority. Everywhere where there are large position differences, you have a potential risk.
Asking all stakeholders to provide new stories can help you estimate completeness.
在进行战略规划时，内部客户往往更关心需求的功能。
我倾向于使用支持可追溯性的工具创建功能路线图（我更喜欢 Sparx Systems 的 Enterprise Architect，但很多工具都可以）。我会在项目发起人级别审查所需的功能及其所需的顺序。
然后，我与适当的人员（有时是业务专家、业务分析师或高级 IT 人员，例如架构师）合作，将每个功能分解为一组高级需求。我创建了从高级需求到功能的可追溯性。此时，需求通常处于“添加 ABC 屏幕”、“添加 DEF 屏幕”、“创建后台进程以重新计算 XYZ”等级别，没有进一步的细节。此时，我与适当的人员合作，根据任何可用的指标（从直觉到屏幕平均添加时间的统计数据）来估计每个高级要求的工作量。然后，我的建模工具总结了每个功能的总估计工作量，然后可以将其呈现给项目发起人并放入项目计划中。
然后我们开始迭代来解决第一个功能或功能集。每个高级需求都被细化为详细需求（“屏幕 ABC 需要名字字段，最大长度 40，必填”等等）。根据项目需求，我们可能会重新估计更详细需求的工作量，并将其汇总到可追溯的高级需求。更常见的是，开发人员将被分配开发 Screen ABC，在冲刺计划工具中输入他自己的估计，并且该估计将回滚到原始模型。由于他正在实现（和估计）的需求追溯到高级需求，而高级需求又追溯到功能级别，因此当我们进入每次迭代时，计划会不断更新。
设置它需要一些纪律和努力，但这是非常值得的。
When doing strategic planning, internal customers tend to care more about features that requirements.
I tend to create a feature roadmap using a tool that supports traceability (I prefer Enterprise Architect by Sparx Systems but many tools will do). I review the desired features and the order they are needed in at the project sponsor level.
Then, I work with appropriate individuals (sometimes business experts, business analysts, or senior IT folks such as architects) to break down each feature into a set of high level requirements. I create traceability from the high level requirements to the features. At this point, the requirements are often at the level of "Add an ABC screen", "Add a DEF screen", "Create a background process to recompute XYZ" and so forth, without further details. At this point, I work with appropriate people to estimate the effort for each high level requirement based on whatever metrics are available (ranging from gut feelings to statistics on how long e.g. screens take on average to add). My modeling tool then sums up the total estimated effort for each Feature, which can then be presented to the project sponsors and placed in a project plan.
Then we start an iteration to address the first Feature or Feature Set. Each high level requirement is refined into detailed requirements ("Screen ABC needs a First Name field, max length 40, required" and so forth). Depending on project needs, we may re-estimate effort for the more detailed requirements and roll them up to the high level requirement they trace back to. More commonly, a developer will be assigned to develop Screen ABC, will enter his own estimate in the sprint planning tool, and that estimate will roll back to the original model. Since the requirements he's implementing (and estimated) trace to the high level requirements, which trace to the feature level, the plan is constantly updated as we get into each iteration.
It requires some discipline and effort to set this up, but it is well worth it.
如何进行大局敏捷？可以这样想：瀑布项目中业务分析师的主要目的是提出基本行为要求的最小但高质量的总体情况，而敏捷项目中业务分析师的主要目的是提出对基本行为要求有一个最小但高质量的总体了解。
How to do big picture Agile? Think of it this way: The primary purpose of a business analyst in a Waterfall project is to come up with a minimal yet quality big picture of the essential behavioral requirements, and the primary purpose of a business analyst in an Agile project is to come up with a minimal yet quality big picture of the essential behavioral requirements.
“SAFe”通过资助“敏捷发布列车”而不是项目来解决这个问题：
http://www.scaledagileframework.com/预算/
"SAFe" fix this by funding "agile release trains" instead of Proyects:
http://www.scaledagileframework.com/budgets/