Beyond Sprints: A New Approach to Efficient Software Development

By: Alon Cohen & Grok

Date: June 9th, 2025 (published two days later)

In my earlier blog post, "Do You Prioritize or Multitask?", I examined the drawbacks of rigid prioritization and the necessity of effective interrupt handling in software development. I argued that an obsession with "first priority" tasks often leads to tunnel vision, where developers neglect broader team needs, slowing down the entire organization. Since writing that post, I’ve observed another common practice that exacerbates these issues: the sprint-based development model, or as some call it, a religion. While sprints are a cornerstone of Agile methodologies, my experience suggests they can hinder efficiency, extend project timelines, and create silos within teams. In this post, I propose a new approach to project management that replaces sprints with a continuous task pool, emphasizes daily releases, and prioritizes organizational collaboration over individual task completion.

The Problem with Sprints

Sprints, typically spanning one to two weeks, are designed to focus teams on a set of tasks to deliver incremental value. However, in practice, they often lead to unintended consequences:

1. Undercommitting to Tasks: Developers, wary of overpromising, tend to select fewer tasks than they can realistically handle. This cautious approach stems from a desire to ensure all tasks are "completed" by the sprint’s end, but it reduces overall throughput. As Parkinson’s Law suggests, work expands to fill the time available, meaning tasks often take longer than necessary simply because they’re constrained by the sprint’s artificial timeline.
2. Resistance to Interruptions: Sprints discourage handling unplanned work, such as fixing bugs reported by other teams or addressing customer issues. Developers, focused on their sprint goals, view these interruptions as threats to their deliverables. This creates friction between teams, slows down responses to critical issues, and ultimately harms the customer experience.
3. The "First Priority" Trap: As I discussed in my previous blog, the phrase "first priority" is often weaponized to justify ignoring broader team/company needs. In a sprint-based system, developers usually use this excuse to avoid collaborating with other teams or assisting colleagues, thereby further isolating efforts and reducing organizational efficiency.

These issues compound over time, leading to delayed projects, frustrated teams, and a culture where individual task completion takes precedence over collective success. There has to be a better way.

A New Model: Continuous Task Flow and Daily Releases

To address these challenges, I propose a new project management model that eliminates sprints, fosters collaboration, and aligns development with the organization's overall needs. Here’s how it works:

1. Continuous Task Pool: Instead of locking tasks into fixed sprints, maintain a prioritized pool of tasks that developers draw from continuously. Tasks are categorized by urgency and impact (e.g., customer-facing bugs, new features, technical debt, revenue generation). Developers select tasks based on their skills and the organization’s immediate needs, ensuring flexibility and responsiveness. This approach eliminates the artificial boundaries of sprints and encourages a steady flow of work. There is also no need to include time buffers.
2. Daily Releases (When Possible): Aim to release code to production daily, or as frequently as feasible. Daily releases enable QA teams to test and perform regression testing incrementally, catching issues early and reducing the risk of large, error-prone deployments. This aligns with the principles of Continuous Integration and Continuous Deployment (CI/CD), ensuring that code is always production-ready and customer feedback is incorporated quickly.
3. Prioritize Organizational Efficiency: Redefine a developer’s "first priority" as helping the organization function at its highest efficiency. This means assisting other teams with urgent bugs, mentoring colleagues, or addressing customer issues, even if it temporarily delays individual tasks. By fostering a culture of collaboration, teams break down silos and ensure that the entire development pipeline—from coding to deployment to support—runs smoothly.

Benefits of the Continuous Task Flow Model

This model offers several advantages over traditional sprint-based systems:

• Increased Throughput: Without sprint boundaries, developers work at a sustainable pace, selecting tasks that match their capacity and the organization’s needs. This reduces the tendency to undercommit and ensures more work is completed over time.
• Faster Issue Resolution: By prioritizing collaboration, teams respond to bugs and customer issues promptly, improving customer satisfaction and reducing bottlenecks across the organization.
• Improved Quality: Daily releases and incremental testing enable QA to identify issues early, increasing coverage and thereby reducing the likelihood of major defects slipping into production. Regression testing becomes a routine part of the process, rather than a last-minute scramble.
• Enhanced Team Cohesion: When developers prioritize helping others, silos dissolve, and teams work as a unified whole. This fosters a culture of mutual support and shared accountability.

Implementing the Model

Transitioning to a continuous task flow model requires careful planning and a cultural shift. Here are some steps to get started:

1. Set Up a Task Management System: Use a tool like Jira, Trello, or Linear to create a centralized task pool. Ensure tasks are clearly prioritized based on business needs and tagged with relevant metadata (e.g., urgency, team, skill set).
2. Establish a Release Cadence: Work with QA and DevOps to enable daily or near-daily releases. Invest in automated testing and CI/CD pipelines to streamline the process and minimize manual overhead.
3. Redefine Success Metrics: Move away from measuring individual task completion or sprint velocity. Instead, track organizational metrics like cycle time (from task start to production), bug resolution time, and customer satisfaction.
4. Foster a Collaborative Culture: Encourage developers to view interruptions as opportunities to contribute to the organization’s success. Reward team members who go above and beyond to help others, and celebrate collective achievements.
5. Iterate and Improve: Start with a pilot project to test the model. Gather feedback from developers, QA, and other stakeholders to refine the process over time.

The Continuous Task Flow

The continuous task flow model builds on the idea of removing the rigid structure of sprints and empowering developers to make dynamic decisions about what to work on next. It is also encouraging focused work on one task at a time, but remaining open to helping others when needed.

Conclusion

Sprints, while well-intentioned, often create inefficiencies that slow down development and fracture teams. By adopting a continuous task flow model with daily releases and a focus on organizational efficiency, we can create a more responsive, collaborative, and high-performing development process. This approach aligns with the realities of modern software development, where adaptability and teamwork are critical to success.

I’d love to hear your thoughts on this model. Have you experienced the downsides of sprints in your own work? What strategies have you used to improve development efficiency? Share your insights in the comments below, and let’s start a conversation about building better ways to deliver software.

Sub-Optimal A/B Testing - Why?

By: Alon Cohen Jan 14, 2018, updated: Dec 18, 2020

A/B testing is the primary tool marketing people use to optimize conversions in the digital marketing world. It’s a method to find the better converting version of a webpage or an ad.

The way A/B testing works is that you randomly present page A or page B to your website visitors and check which version of the page converts more visitors. Some tools (like https://www.optimizely.com) make that process relatively straightforward; however, it takes time to collect sufficient evidence to make a clear decision about which page performed better.

So why even bother?

The problem with webpage design is that it is hard to get it right the first time. A designer might think that the call to action button is in the way and move it to where it becomes ineffective. Color schemes and market trends affect how people perceive, understand, and operate a page.

Statistically significant results from an A/B test can help validate a webpage design assumptions and improve on them.

What can go wrong?

If, for instance, you did not assign a 50/50 impression between the A & B versions of the page, you might think that one page performs better. 

In many cases, unless one page is horrible, the other will perform pretty close to the first one, and the statistics can change week after week. You must wait a sufficiently long time, sometimes a few weeks, to get a decisive answer. 

Picking the wrong page will reduce your conversions.

Since you usually use multiple channels to target customers, changes in one medium might affect the A/B test results. Even though A/B testing could be helpful when your two pages are almost similar in performance, it usually takes a lot of work to get conclusive results, and ongoing testing is required.

So what is going on here?

Say you have used the best tools for A/B testing. You waited and got some slight statistical confirmation that one page is better. Why? Because one page was suitable for some people and the other was helpful for others.

The audience is not homogenous. When the results are close, half of the audience liked version A, and the second half liked version B. The sad product is that your bottom line stayed the same despite all your optimization efforts and patience.

Let’s say that 50% of the people like Red and half like Blue to explain it better. If you make the page Red, more red-liking people will convert. If you make the page Blue, more Blue liking people will convert. So it does not matter if the page is Red or Blue; conversions will not improve. 

Is there a solution?

Ideally, you need to have a different version of the webpage for each visitor or at least a separate page for various market segments or buyer personas. Only then could you see improvement in your total performance.

Unfortunately, I have yet to see helpful marketing tools that can tell you (the site) in real-time which version of the page to render to which user. The hope is that such a tool or an API will enable correct personalization of the webpages and drastically improve the conversion. 

It is not about knowing the visitor’s name. It is about understanding the visitor’s social or behavioral profile and displaying the correct page for each visitor’s characteristics.

In simple words, you need a way to show red-loving people the red page and the blue-loving people the blue page. This way, you can improve the total conversions and move from a "local" maximum on the optimization graph to a more "global" sales process optimization.

 

Thoughts?

Have you heard of such a tool or an API? Let me know.