Snowbird to Deer Valley: The Questions Software Development Still Hasn't Answered
Source: martinfowler
In February 2001, seventeen software developers gathered at the Snowbird ski resort in Utah and wrote a short document that would shape the next two decades of how organizations build software. The Agile Manifesto runs to fewer than 100 words for its core values, with twelve supporting principles following behind. Twenty-five years later, Thoughtworks hosted a workshop called “The Future of Software Development” in Deer Valley, Utah, a deliberate geographic echo of the original. Martin Fowler documented the gathering on his bliki, framing it as forward-looking rather than retrospective.
The symmetry is attractive. Same state, different mountain, different problem.
That last part is worth sitting with. The original manifesto was a reactive document. It was written in response to a specific pathology that was killing software projects in the late 1990s: heavyweight, bureaucratic process frameworks, RUP, CMM, SSADM, that prioritized documentation and planning over working software and human judgment. The four values read differently when you know what they were pushing against. “Working software over comprehensive documentation” was a response to teams spending months producing binders that nobody read. “Individuals and interactions over processes and tools” was a response to organizations where the process had become the product.
The manifesto worked, in the sense that the pathology it identified became widely recognized. Waterfall as a dominant methodology largely retreated. Lightweight iterative approaches spread. The idea that teams should ship frequently, adapt to feedback, and protect developer judgment against managerial process theater became orthodoxy.
What Agile Became
The problem is that orthodoxy has a way of becoming the next thing to push against.
Agile succeeded well enough that it got industrialized. By the 2010s, a certification industry had grown up around Scrum. Consulting frameworks like SAFe (Scaled Agile Framework) emerged to apply agile-adjacent language to large organizational structures in ways that many of the original signatories found antithetical to the original intent. Ron Jeffries, one of the Snowbird signatories, spent years writing about what he called “Dark Scrum” — implementations that retained the process artifacts (daily standups, sprints, backlogs) while stripping out the developer autonomy and technical practices that the original authors cared most about.
Dave Thomas, another signatory, gave a talk in 2014 titled “Agile is Dead” that made a useful distinction: the values and principles the manifesto described were real and still worth following, but “Agile” as a branded methodology being sold by consultants had become something else. The noun had swallowed the adjective.
Martin Fowler himself has written repeatedly about this tension, distinguishing between teams that have actually internalized the practices and organizations that perform agile ceremonies while operating by command-and-control logic underneath. The Manifesto for Software Craftsmanship emerged in 2009 partly as a corrective, with its own gathering of practitioners responding to what they saw as Agile’s drift toward process-talk at the expense of technical excellence.
Twenty-five years of institutional capture is the backdrop against which the Deer Valley gathering happened. The question is not just “what is the future of software development.” It is “what kind of gathering can actually produce something useful.”
The Disruption the Manifesto Has No Vocabulary For
Here is where the forward-looking framing becomes genuinely difficult. The challenge Agile was built to address, how humans organize to build software well, has been joined by a second, harder challenge: AI systems can now write significant portions of working code.
This is not a productivity tool in the way that IDEs or version control are productivity tools. Those tools changed how fast humans could do the same work. AI-assisted development changes what the work is. GitHub Copilot, Cursor, and systems like Claude are now generating code that enters production at companies of all sizes. The developer’s role in that process, specifying intent, reviewing output, verifying behavior, maintaining systems, is substantively different from typing every line.
The Agile Manifesto’s twelve principles are almost entirely silent on this. They have things to say about sustainable pace, technical excellence, self-organizing teams, and responding to change. They have nothing useful to say about a world where a developer’s primary constraint is no longer implementation speed but verification quality, whether you can tell if the code an LLM generated actually does what you think it does.
This is the genuinely new question. Not “should we do sprints or kanban” but “what does skilled software development look like when generation is cheap and verification is hard?”
What the Next Framework Needs to Address
The specific pressures accumulating in software development right now cluster around a few areas that any forward-looking framework would need to engage with directly.
The first is the skill composition question. If AI can reliably handle a large fraction of implementation work, the most valuable developer skills shift toward problem decomposition, requirements clarity, system design, and code review depth. These were always important; they become dominant. Organizations that are still hiring and training primarily for implementation speed are building toward a mismatch.
The second is the quality verification problem. AI-generated code can be plausible without being correct, and it can be correct without being appropriate for the specific system context. Standard testing practices were designed to catch errors made by humans who understood the codebase. They are less obviously adequate for catching the specific failure modes of LLM-generated code, which tends toward local correctness and global inappropriateness. The practices that close this gap are still being worked out.
The third is the context preservation problem. Software systems accumulate decisions and their rationales over time. When code is generated rather than written, those decisions often go undocumented. The prompt used to generate a module is gone. The reasoning behind a particular approach is absent. Technical debt in AI-assisted codebases may compound differently than in human-written ones, and existing practices for managing that debt may not transfer cleanly.
Whether the Format Still Works
There is a meta-question lurking here about whether a gathering of practitioners writing principles is still the right mechanism for shaping what comes next. The Snowbird meeting worked partly because the seventeen attendees were unusually aligned: they were pushing back against something they all agreed was wrong, and the alternative they proposed had years of accumulated practice behind it. The values were distilled from experience, not invented from theory.
A 2026 gathering faces a harder task. The disruption is happening in real time, without enough history to distill from. The practitioners with the most direct experience of AI-assisted development are often at companies not historically connected to the Agile tradition. The questions are messier, the experiences more varied, and the consensus harder to find.
That does not make the effort futile. The value of these gatherings is often not the document that emerges but the shared frame that participants carry back. If the Deer Valley workshop moves the community toward asking sharper questions, about verification, about skill evolution, about what technical excellence looks like in AI-assisted codebases, then it will have done something useful, even if it does not produce a document with the reach of the original manifesto.
The original Agile Manifesto’s most durable contribution was not its specific prescriptions but its insistence on looking clearly at what was actually making software development fail and naming it honestly. Doing that again, for a different set of failure modes, is worth the trip to Utah.
Martin Fowler documented the Deer Valley workshop on his bliki in February 2026. The original Manifesto for Agile Software Development was signed at Snowbird, Utah in February 2001.