John M.’s Post

"Welcome changing requirements, even late in development." In 2001 this was radical. Waterfall had made late change the enemy — a threat to the plan, the budget, the signed-off spec. The manifesto was saying: stop treating change like a failure. It's information. Welcome it. Twenty-four years later most teams will tell you they embrace change. Agile culture has made flexibility a stated value almost everywhere. But I've watched async quietly recreate waterfall's rigidity. Just without the paper trail. Waterfall resisted late change because everything was linear and document-heavy. Unpicking a requirement meant unpicking a chain of approvals. Slow, visible, painful. Async resists late change for a different reason. People are heads-down in their own lanes. Context is scattered across threads and tools and timezones. By the time a change request has been messaged, acknowledged, clarified, and actioned — the window has sometimes already closed. Different mechanism. Same result. At an agency I worked at, a client wanted a design change. Simple. Fifteen minutes of work, maybe less. But the request came in as a message. A word here, a phrase there that needed clarification. The clarification didn't happen fast enough across the timezone gap. The nuance was missed. What should have been a quick turnaround became two days of rework and a client who noticed. Nobody ignored the change request. Nobody resisted it. The system just had no mechanism for the moment when a message wasn't enough. Welcoming change requires more than willingness. It requires a communication infrastructure fast enough to actually act on it. We've got the culture. We haven't built the infrastructure.

I've been talking about this with some coworkers recently. The concept of scrum as we know it is dead. Scrum was designed for human speed. You would meet to discuss what tasks from the backlog could be done in the next 2 weeks. You assigned points to user stories based on the amount of human effort. You worked over a 2 week period to complete the work. At the end of the sprint, you might deploy the feature to production. When features can be developed, tested, and deployed in minutes to hours with AI-native development, the traditional SDLC collapses. All of the sprint ceremonies go away as a tighter development loop takes root. How humans fit into that process is still being figured out across industry. For commercial software teams, the workflow shift is relatively straightforward. The harder question for development teams in government IT is that contracts, compliance frameworks, and federal acquisition vehicles are explicitly built around the old SDLC. Beyond government development shops simply gaining access to AI-native development tools (which may take some time), bridging AI-native development practices to procurement and governance structures is also needed. 

Looking for a good book to read?

Robert Martin's well-known series "Clean Code", "Clean Architecture", "Clean Agile", and "The Clean Coder" explores the fundamentals of professional software development. These books explain how to write better code, design reliable software architecture, and apply Agile practices effectively. Beyond technical knowledge, Martin also focuses on professionalism in development teams, making this collection also valuable for testers, project managers, and technical leaders.   "Kanban" by David J. Anderson introduces one of the most practical and flexible approaches to managing work in tech teams. The book explains how evolutionary change and continuous workflow can improve productivity while reducing resistance during organizational transformation. Anderson combines theory with practical insights, showing how the Kanban system helps teams manage workload, maintain stability, and build a culture of continuous improvement.   In "Digital Human," Chris Skinner looks at the broader impact of digital transformation on business and society. The book explores how organizations can adapt to an increasingly digital world and use technology to remain competitive. It is particularly relevant for leaders, entrepreneurs, and technology professionals who want to better understand how digitalization reshapes industries and business models.

⚠️ Technical Debt: The Hidden Challenge in Agile Development Agile helps teams deliver software faster and more frequently. But in the rush to ship features quickly, teams sometimes take shortcuts in code, architecture, or documentation. This is what we call Technical Debt. Just like financial debt, it may help you move faster today — but if left unmanaged, the cost compounds over time. 🔍 The Problem Technical debt often arises from: • Poorly structured code • Development shortcuts to meet deadlines • Outdated or poorly designed architecture These decisions may seem harmless initially, but they slowly accumulate and affect the entire system. 📉 The Impact When technical debt grows, teams start experiencing: • Slower development speed • Increasing production bugs • Difficult maintenance and debugging Instead of building new features, teams spend more time fixing existing issues. ✅ The Solution Mature Agile teams manage technical debt proactively: • Prioritize refactoring as part of sprint planning • Automate testing to detect issues early • Track technical debt in the Agile backlog Addressing technical debt regularly ensures that teams can maintain speed, quality, and scalability. 💡 Key takeaway: Agile is not just about delivering faster — it’s about delivering sustainably. 💬 How does your team manage technical debt in Agile projects? #Agile #TechnicalDebt #SoftwareDevelopment #SDLC #ITProjectManagement #DevOps #AgileDevelopment #EngineeringExcellence

The Agile Manifesto values working deliverables over comprehensive documentation. Here's the irony: async work has made us more dependent on documentation than ever. And I'm not sure that's making us better at delivering. Take the standup. Its purpose is simple — align the team, surface blockers, keep things moving. A few minutes of genuine presence and the day runs better. But when every standup is automatically recorded and transcribed by a tool like Notion, something shifts. The safety net becomes a permission slip. Why be fully present when you can always look back? I'll be honest — I'm not guilt-free here. I've tuned out of meetings where "my part" is over knowing the transcript would be there if I needed it. It isn't right. But it's the truth. And when enough people on a team are doing the same thing, the standup stops being a standup. It becomes a ritual. People are physically present but mentally elsewhere. The blockers don't surface because nobody's really listening. The alignment doesn't happen because nobody's really there. The documentation meant to support the work quietly becomes a substitute for it. The manifesto's authors weren't anti-documentation. They were pro-delivery. They understood that documentation is only valuable in service of the thing you're actually trying to build. Async gives us better tools to capture everything. I'm just not convinced capturing everything is the same as being present for the team and absorbing the meeting contents.

Agile is a Method, Not a Hall Pass for Poor Engineering. In the world of critical systems—where failure isn't just a bug, but a catastrophe, there is a dangerous misconception that "Agile" means "ad-hoc." As I highlight in my textbook "Systems Engineering in Agile Software Development", the faster we iterate, the more we need the structural integrity of Systems Engineering. Being Agile is no excuse for poor engineering rigor. In fact, if you’re building complex, interconnected systems, rigor is the only thing that makes Agility possible. The "Rigor Gap" in Modern Agile Many teams use Scrum as a shield to bypass documentation, requirements management, and architectural planning. They prioritize the "Sprint" over the "System." But as Rosson argues, this leads to: ➡️ Desynchronized Artifacts: When code moves faster than the design, the "digital thread" breaks. ➡️ Discovery of Late Defects: Without rigorous verification, you aren't "failing fast"—you’re just delaying a crash. ➡️ Brittle MVPs: A Minimum Viable Product that lacks a systems-thinking foundation isn't a prototype; it’s technical debt. The SEFAD Approach: Balancing Agility & Rigor To move fast without breaking things (especially things that shouldn't be broken, like medical devices or defense software), we need Systems Engineering Focused Agile Development (SEFAD). This means: ➡️ Model-Based Systems Engineering (MBSE): Replacing static, disconnected docs with a single source of truth that evolves with the code. ➡️ Structured Requirements: Moving beyond "User Stories" to establish a comprehensive requirements baseline that minimizes risk. ➡️ Rigorous QA: Integrating quality assurance into the heartbeat of the sprint, not as an afterthought. The Bottom Line Agility is about the ability to pivot. But you cannot pivot a system that is brittle or poorly understood. True engineering rigor provides the "brakes" that allow you to drive faster around the corners. If your "Agile" process results in constant hotfixes and architectural chaos, you aren’t being Agile. You’re just rushing. Build with rigor. Deliver with speed. Balance both. #SystemsEngineering #Agile #SEFAD #SoftwareEngineering #DallasRosson #TechLeadership #CriticalSystems #MBSE

User Stories and Epics are becoming relics. Here's why: For decades, we've used Epics and User Stories to bridge the gap between business intent and technical execution. They were the best tool we had to describe what needed to be built. But describing software is no longer the bottleneck. With the dramatic drop in cost and time to prototype, teams can now vibe code a working concept in hours — and put it directly in front of the customer before a single sprint is planned. That's not a mockup. That's not a wireframe. That's a conversation you can click through. When a customer reacts to a real, interactive prototype, the feedback loop is richer, faster, and far less prone to misinterpretation than a carefully written acceptance criterion ever was. The dev team no longer needs a story that says "As a user, I want to…" — they need a prototype that shows exactly what was validated with the customer. Epics and User Stories weren't the goal. Shared understanding was. We now have a better way to get there. The Agile Manifesto celebrated working software over comprehensive documentation. Ironically, User Stories became exactly that — documentation. It's time for the framework to evolve and embrace the tools that finally make that original promise real. The question isn't whether Agile needs to change. It's whether we're willing to let it.

Y’all have journeyed with me from Waterfall to Agile/Scrum to XP to TDD to BDD to Lean to JTBD… now join me in the new hotness: ✨ Spec-Driven Development. ✨ Save your tokens and start with a spec worth building from: 🔎 Step 1: Capture the problem, not the solution. PM’s job. “Users can’t find their transaction history when filtered by date,” not “add a search bar.” If your spec starts with a feature, you’ve already skipped the most important step. ✍️ Step 2: Draft the What. Still PM. Define the outcome, the constraints, and what would make this wrong. If you can’t articulate the failure condition, the spec isn’t done. 🔬 Step 3: Eng stress-tests for ambiguity. Not feasibility. Not architecture. Just: find every “it depends” hiding in the language. This is where “fast” becomes “under 200ms” and “simple” becomes “3 fields max.” 🫱🏻🫲🏼 Step 4: Joint sign-off on acceptance criteria. PM + Eng. This is the actual contract. Nobody writes code and no LLM generates code until this exists. The reason spec-driven development breaks down isn’t that specs are hard to write. It’s that we skip the upstream work that makes a spec precise enough to be useful. LLMs are extraordinarily good at executing an unambiguous spec. They’re just as good at confidently building the wrong thing from a vague one. As always… go slow to go fast, and may your momentum snowball in all the right directions. 🌨️

I’ve been reading the original Agile Manifesto. Four values. Twelve principles. Written in 2001 (Which made me expect it to feel a little outdated.) Back in 2001, seventeen developers met at a ski resort in Utah and wrote it. That alone sounds like the setup to something that shouldn’t still be relevant, but here we are. And reading it now, in 2026? It doesn’t feel old. If anything, it feels a bit too accurate. You see the same lines everyone throws around: “Responding to change over following a plan.” “Working software over comprehensive documentation.” “Individuals and interactions over processes and tools.” “Customer collaboration over contract negotiation.” I’ve read those before. Plenty of times. But sitting with them properly this time, they don’t come across like “principles” in the formal sense. They feel more like reminders, the obvious stuff we somehow keep forgetting. That’s probably the part that stuck with me. These aren’t really software principles. They’re people principles. They just happen to be applied to software. Which explains a lot. Because everything else has changed since 2001. The tools, the tech, the way we build things, But people?Not that much. We still overcomplicate things. Still hide behind process. Still struggle with the same basic stuff: communicating, adapting, actually working together. So yeah… maybe it makes sense that this has lasted. Anyway, if you’ve never actually read the original Manifesto, it’s short. Like a 4 minute read, but definitely worth every one. I genuinely believed I already knew it. I didn’t.

Twenty years ago, the Agile Manifesto transformed software development by emphasizing the importance of responding to change. This approach resonated with practitioners who understood the need for adaptability but struggled to express it. Today, AI has shifted the landscape. While producing software has become more affordable, comprehending it has become increasingly complex. The original values of the Manifesto do not fully address this evolution. In response, I have crafted an addendum: - Shared understanding over working software - Independent challenge over efficient agreement - Teaching the why over delivering the what - Pace of learning over pace of shipping While the original values remain essential, the new values provide the context that makes them truly meaningful. For a deeper dive into the full addendum, including three updated principles and the rationale behind each change, visit: https://lnkd.in/gkHVr6D2