Signals & Levers Elisabeth Hendrickson, Joel Tosi & Charles Humble

The podcast discussion centers on systems thinking as a crucial framework for addressing the increasing complexity and uncertainty in modern software development. The conversation highlights how traditional approaches like Agile and DevOps are no longer sufficient in navigating today's socio-technical systems, especially with the rise of AI and evolving organizational challenges. Systems thinking is presented as a way to understand interdependencies, recognize patterns, and manage "wicked problems" - complex issues with no definitive solutions - by focusing on adaptation, learning, and improved decision-making rather than seeking control or predictability.

A key theme is the shift from an extraction mindset - focused on efficiently delivering known solutions - to an exploration mindset that embraces uncertainty and emergent challenges. The discussion emphasizes the importance of moving beyond misleading proxies such as velocity or lines of code, which create illusions of progress and control, in favor of more meaningful metrics like cycle time and variability analysis. Storytelling is advocated as an effective method for conveying systems concepts, as illustrated by the narrative structure of the book Signals and Leavers, which uses real-world scenarios to explore systemic dynamics. Additionally, the role of leadership in shaping culture through actions, rituals, and reinforcement of desired behaviors - rather than mandates - is explored, particularly in moving away from hero cultures toward collaboration and shared responsibility.

• What if you audited your product's core metrics for proxy illusions?

  • Move: Identify one key metric you use (e.g., feature velocity, PR count, daily logins) and trace whether it's a direct outcome or a proxy. Map what it actually measures versus what you believe it reflects (e.g., productivity, user value). Replace it with a tighter, more direct signal like cycle time or user task completion rate.
  • Why Now?: AI and rapid iteration are increasing the gap between activity and outcome - teams can look busy while shipping little real value. Proxy misuse leads to misaligned incentives, especially as automation (e.g., AI-generated code) distorts traditional metrics.
  • Expected Upside: Clearer feedback loops help you pivot faster, reduce waste, and align your development rhythm with actual user or business impact - critical when operating solo and every hour counts.

• What if you ran a 48-hour self-organization experiment on your next feature build?

  • Move: Instead of planning all tasks upfront, define only the outcome and constraints (e.g., "ship a working API integration in 48 hours, no meetings"). Use that time to self-organize around obstacles, document bottlenecks, and reflect on where command-and-control habits crept in - even self-imposed.
  • Why Now?: The shift from extraction to exploration means solo developers must embrace uncertainty. If you're used to following templates or frameworks rigidly, this builds agility in navigating ambiguity - a core skill as AI reshapes tooling and expectations.
  • Expected Upside: You surface hidden inefficiencies, reduce ritualized work, and build adaptive decision-making muscle. Over time, this leads to faster, more resilient solo shipping cycles without external coordination overhead.

• What if you modeled your solo workflow as a causal loop diagram to find high-leverage nudges?

  • Move: Sketch a simple causal loop diagram of your current development process - include delays (e.g., feedback time), reinforcing loops (e.g., burnout delay stress), and signals (e.g., notifications, deadline alerts). Identify one small, high-leverage intervention (e.g., automating a status update, changing commit review timing) that could shift the system.
  • Why Now?: As a solo operator, you lack the feedback buffers teams provide. Small systemic tweaks can prevent oversteering, latency misjudgments, or burnout - especially as AI tools create new latency points (e.g., prompt iteration, hallucinated code cleanup).
  • Expected Upside: You replace reactive stress with intentional design, unlocking compound improvements in focus, delivery rhythm, and sustainability - turning your solo operation into a learning, self-correcting system.

• Adopt the CREATE framework to evaluate business signals across dimensions like capacity, risk, and economics, ensuring decisions are based on holistic data rather than misleading proxies like velocity or headcount.
• Replace velocity tracking with cycle time measurement in your development workflow to expose real bottlenecks and reduce the illusion of progress caused by arbitrary output metrics.
• Use causal loop diagrams (CLDs) to map small, high-leverage changes in your solo workflow or tooling setup, avoiding over-correction and allowing time for feedback loops to reveal actual impact.
• Identify and eliminate one misleading proxy metric (e.g., lines of code, tool usage time) from your productivity tracking, replacing it with a direct outcome indicator like feature completion or user feedback response time.
• Implement a personal ritual or feedback loop - such as a weekly review or public log - that reinforces desired behaviors (e.g., sustainable pace, learning, system thinking) and counters solo operator isolation by creating accountability and reflection.