Saturday, December 13, 2025

Good talks/podcasts (Dec)

These are the best podcasts/talks I've seen/listened to recently:
  • This Mental Model Changed How I Design Software FOREVER 🔗 talk notes (Emily Bache) [AI, Agile, Architecture, Mental models, tdd] [Duration: 00:09] (⭐⭐⭐⭐⭐) Applying the mental model of Test-Driven Development (TDD) as an empirical engineering approach to master software design and manage complexity alongside Agentic AI tools.
  • From here to there and back again 🔗 talk notes (Simon Wardley) [AI, Strategy, Technology Strategy] [Duration: 00:57] Simon Wardley introduces maps for strategic situational awareness, detailing how technological evolution, inertia, and the rise of AI impact decision-making and software architecture, emphasizing the challenge of deciding where humans maintain control
  • Who Does What by How Much? Customer-Centric OKRs explained with Jeff Gothelf and Josh Seiden #ccokrs 🔗 talk notes (Jeff Gothelf, Josh Seiden) [Agile, Company Culture, Management, Strategy] [Duration: 01:14] (⭐⭐⭐⭐⭐) Experts Jeff Gothelf and Josh Seiden detail how to define customer-centric Objectives and Key Results (OKRs) by focusing on measurable outcomes, encapsulated in the framework’s core question: "Who Does What By How Much?"
  • Jim Womack on Lean Thinking: Past, Present & Future 🔗 talk notes (Jim Womack) [Company Culture, Lean Manufacturing, Management] [Duration: 00:32] (⭐⭐⭐⭐⭐) Jim Womack offers a comprehensive retrospective and prospective view of Lean thinking, exploring its evolution, current relevance, and future potential for a "second lean leap".
  • Vibe coding in prod | Code w/ Claude 🔗 talk notes (Erik Schluntz) [AI, Agile, Continuous Delivery] [Duration: 00:31] A discussion on how to safely practice "vibe coding" (letting AI generate code while forgetting the code exists) in production by acting as the AI's Product Manager and focusing on verification of leaf nodes and abstraction layers.
  • Analytics for not-so-big data with DuckDB 🔗 talk notes (David Ostrovsky) [Data Engineering, Performance] [Duration: 01:02] A deep dive into DuckDB, an embedded analytical database optimized for running high-performance analytical queries on "medium data" (1-100 GB range) locally on a single machine, with seamless integration for Python and diverse data sources
  • The New Code — Sean Grove, OpenAI 🔗 talk notes (Sean Grove) [AI, Agile, Architecture, Devops] [Duration: 00:21] OpenAI's Sean Grove introduces "The New Code," arguing that specifications are the universal artifact of intent, crucial for aligning both humans and advanced AI models.
Reminder: All of these talks are interesting, even just listening to them.

You can explore all my recommended talks and podcasts on the interactive picks site, where you can filter by topic, speaker, and rating: Feedback Welcome!
Your feedback and suggestions are highly appreciated to help improve the site and content. Feel free to contribute or share your thoughts!
Related:

Custom GPTs: New Permanent URLs

Quick heads up: my Custom GPTs have new URLs after switching ChatGPT accounts. These should be the permanent ones.

All four GPTs are now available at their updated locations:

The functionality remains the same — only the URLs have changed. If you've bookmarked the old links, please update them.

You can find all my projects, including these Custom GPTs, at eferro.github.io.

Saturday, November 29, 2025

Cursor Commands Added to augmentedcode-configuration

I've just updated my augmentedcode-configuration repository with Cursor commands that codify my XP/Lean development workflows.

What's new:

Added .cursor/commands/ with 8 reusable command patterns:

  • plt-code-review — Review pending changes (tests, maintainability, project rules)
  • plt-increase-coverage — Identify and test high-value untested paths
  • plt-plan-untested-code — Create strategic plans to close coverage gaps
  • plt-predict-problems — Predict production failure points proactively
  • plt-technical-debt — Catalog, classify, and prioritize technical debt
  • plt-mikado-method — Apply Mikado Method for safe incremental refactoring
  • plt-xp-simple-design-refactor — Refactor using XP Simple Design principles
  • plt-security-analysis — Pragmatic security risk assessment

Purpose:

These commands codify recurring workflows as reusable patterns. Instead of ad-hoc prompting, they provide consistent guidance for the AI to:

  • Work in small, safe steps
  • Focus on tests and maintainability
  • Apply Lean/XP principles
  • Follow project-specific conventions

They work alongside the existing base rules, creating a more complete configuration for AI-augmented development.

👉 Check them out: .cursor/commands/

This is an update to my original post: My Base Setup for Augmented Coding with AI

Perverse Incentives, Predictable Results: When Your System Sabotages Your Teams

It's a strange paradox. It took the manufacturing industry 50 years to move past the ideas of Frederick Winslow Taylor, known as Taylorism or Scientific Management. Yet in software development, a creative, knowledge-based discipline where these ideas are least effective, we continue to apply them universally.

Taylorism in a software context is the practice of maximizing the local utilization of each individual. We treat people like resources in a factory, keeping them 100% busy with their specialized tasks. This creates a cascade of perverse incentives that actively undermine collaboration, destroy flow, and cripple the efficiency of the entire system.

This article explores the three most common traps this thinking creates and offers a practical, systemic path toward improvement.

1. The Trap of Resource Efficiency

The Core Fallacy

Most organizations are obsessed with individual performance and 100% resource utilization. The goal is to keep every person busy all the time, believing this equates to maximum productivity. However, basic queueing theory teaches us that running any system at full capacity only generates blockages, chronic bottlenecks, and massive wait times. As a wise colleague once said, "If we optimize locally, in most cases we make everything worse."

The Connection to Taylorism

This is a direct application of Taylorism: maximizing the utilization of each "human resource" locally. We decompose work, assign it to specialists, and measure them on their individual output, ignoring the devastating impact on the system as a whole.


The Consequences

When you incentivize local optimization, the negative results are entirely predictable.

  • Perverse local incentives: We reward metrics that are easy to measure but destructive to the whole. This includes rewarding a high number of commits, celebrating people for "being 100% busy," or lionizing "heroes" who constantly put out fires.
  • Predictable negative results: These incentives inevitably lead to chronic bottlenecks, constant rework (also known as "failure demand" because you're fixing things that failed the first time), and a toxic hero culture where knowledge is hoarded and collaboration is discouraged.

The Alternative: Flow Efficiency

The antidote to this trap is shifting our focus from resource efficiency to flow efficiency. The book This is Lean explains the difference well.

  • Resource Efficiency: This is a process where work is handed off between specialists in silos. To keep each specialist busy, a queue of work forms before each handoff. From the customer's perspective, this is incredibly inefficient, as their request spends most of its time waiting in a queue.
  • Flow Efficiency: This is a team-based approach where everyone collaborates to finish a single piece of work. There are no "my parts." The team owns the work from start to finish. This delivers value to the customer much faster and eliminates the immense waste and rework inherent in siloed handoffs.

2. The Trap of Disconnecting from "Why"

The "Feature Factory" Anti-Pattern

A common anti-pattern is the "feature factory," where teams operate like an assembly line. Someone defines requirements, others implement them, and no one on the team connects with the customer or the actual impact of the work. Success is measured by output, not outcome.

The Connection to Taylorism

This is another core tenet of Taylorism: the rigid separation of "thinkers" from "doers." It promotes the unquestioning execution of specifications, regardless of whether those specifications actually solve a real customer problem.

The Predictable Results

Building without a clear purpose has disastrous and wasteful consequences.

  • Irrelevant products: Features are built that nobody uses.
  • Wasted talent: People work hard on things that simply don't matter.
  • Unnecessary complexity: Technology is over-engineered without a connection to a real-world need, creating a massive maintenance burden.

Advocate for Empowered Teams

The alternative is an empowered product team that deeply understands the purpose of its work: what problem they are solving, for whom, and why. These teams don't just blindly follow specs; they adapt solutions to meet real user needs, achieving far greater impact and velocity with less effort.

The Evolution to a Product Team

The journey from a siloed, handoff-driven process to a true product team is an evolution. An effective model shows the team's boundary of collaboration expanding across the entire value stream. In a traditional Waterfall model, each step (Opportunity Selection, Design, Build, Test, Release, Run) is a separate silo. In an ideal Product Team, the entire team collaborates across the whole process, from identifying the opportunity to operating the solution and learning from its impact.

3. The Trap of Deferred Quality

The Core Myth

There's a false dilemma that pits quality against velocity. We're taught to believe there's a tradeoff: you can be "fast without quality" or "slow with quality." This is a foundational myth in our industry.

The Truth

The data is clear. As shown in years of research from the Accelerate/DORA reports, the highest-performing teams have both high quality and high speed. The truth is: Quality does not compete with velocity; it enables it. Of course, context matters. A one-shot script, an MVP, or a proof of concept have different quality constraints than a core product. But for any sustainable product development, building quality in from the start through practices like testing and fast feedback is the only path to sustainable speed. A low-quality approach leads to a progressive slowdown as technical debt and failures accumulate.

The Connection to Taylorism

This myth is a direct descendant of a Taylorist mindset. It treats productivity as a measure of immediate outputs, ignoring sustainability. Quality is seen as a separate, final inspection phase, rather than something built into the process from the beginning.

The Negative Cycle

This mindset creates a system that actively discourages quality.

  • Perverse Incentives: The system rewards behaviors that produce low quality. We celebrate heroes who fix crises (often of their own making), equate long hours on weekends with commitment, and reward improvised hacks that create future problems.
  • Predictable Results: The consequences are severe and unavoidable. Teams are trapped in a cycle of chronic firefighting. Technical debt grows relentlessly, and the organization suffers from a high rate of talent drain as good people flee the constant chaos.

4. The Path Forward: Systemic Improvement

As W. Edwards Deming taught, over 90% of an organization's performance is a result of the system, not the individuals within it. The responsibility of management is not to blame people but to change the system so that work can flow and people can grow.


Here are actionable strategies to start changing your system.

Lead by Example

As a manager, you must model the behaviors you want to see. If you want teams to write tests, you should write tests. If you want them to refactor, you refactor. Make the desired behaviors visible and celebrate them publicly. Your job is to improve the system, not to find culprits.

Embrace Blameless Postmortems

Analyze incidents and errors transparently with the sole purpose of finding and fixing systemic weaknesses. The goal is to learn and improve, not to assign blame. When the system allows a mistake to happen, the focus must be on strengthening the system.

Show Vulnerability to Build Safety

To create an environment of psychological safety where people feel comfortable highlighting problems, leaders must be the first to show vulnerability. I often share my own past mistakes like the time I took down the phone system for an entire town or made a critical DNS error. Sharing these stories openly shows that errors are a part of work and that the important thing is what we learn from them.

Hack Your Performance Reviews

Traditional performance reviews are often toxic, reinforcing the individualistic, Taylorist mindset. If you are required to use them, hack them. Sometimes you must reinterpret corporate-level mandates to create the right local incentives. Subordinate individual accomplishments to the person's contribution to the team's overall impact. Focus on how they helped the team succeed, not just what they did on their own.

Build End-to-End Ownership

Create cross-functional teams that own a problem from end to end. This often means fighting against the silo mentality. A strategy I've used is to have my team actively take on more work (like operations or QA tasks) to eliminate external dependencies. This gives the team full control, deepens their knowledge, and allows them to optimize for the entire value stream.

Redefine 'Done'

A task is not "done" when the code is committed. It's not "done" when it's deployed. Work is only truly "done" when its impact on the customer has been validated with real feedback. This reinforces a product mindset and focuses the team on outcomes, not just output.

Hire for Mindset

Prioritize mindset and attitude over a checklist of specific technical skills. You can teach someone a new programming language; it's much harder to teach them that quality is their responsibility.

  • Product Thinking: Ask product management questions in interviews, like "What products do you admire and why?" or "How would you measure the impact of this feature?" Invite product managers into engineering interviews to help assess this.
  • Collaboration: Assess real collaboration, not just talk. When possible, have candidates work with the team for a day (in a paid, respectful way) on a real problem.
  • Flexibility: Your career path must reward generalists who provide flexibility, not just specialists.

Master Your Workflow with Kanban

Many teams use Kanban boards, but few use them correctly as a pull system. The three most important rules are:

  1. Use WIP (Work In Progress) limits. This is the simplest and most powerful way to optimize flow.
  2. Read the board from right to left. During stand-ups, review the work, not the people. Start with what's closest to being "done" (validated impact) and work backward. The focus must always be on finishing work, not starting new work.
  3. Use slack to unblock. When WIP limits leave someone without an immediate task, they should not pull new work. Their job is to help colleagues with open tasks, unblocking work further down the chain.

Reducing Resistance by Turning Change Into Experiments

The status quo naturally resists change. To move forward, we need to build the capability to generate change continuously, not just through occasional big initiatives. Approaches inspired by Lean Change Management can help: make small, frequent adjustments, learn quickly, and evolve based on evidence rather than assumptions.

One powerful tactic is to present changes as experiments. Framing them this way reduces resistance, creates psychological safety, and encourages people to engage with curiosity rather than fear. Even when the goal is meaningful transformation, breaking it into small, testable steps makes progress far more sustainable.

Define clear success criteria and a limited timeframe. This lowers resistance and allows you to validate ideas with data. As Grace Hopper famously said, “It’s easier to ask for forgiveness than it is to get permission.”

Conclusion: A Better Way to Work

A bad system will always defeat a good person. The Taylorist principles so common in our industry create systems that are destined to fail, leading to wasted effort, frustrated teams, and mediocre results.

We are discovering better ways to work. Through this experience, we have learned to value:

  • Collaboration and shared responsibility over heroes and a culture of blame.
  • Global optimization over local efficiency and specialized silos.
  • Significant impact and results over occupation and "being busy."
  • Autonomy with purpose over rigid control and supervision.
  • Continuous learning and adaptation over predefined and static processes.

By focusing on changing the system instead of blaming the people, we can create environments where teams can truly thrive and deliver exceptional value.

Management frameworks and their impact on software development.

Further Reading and Resources


Saturday, November 22, 2025

Scaling Systems and Teams: Five Mental Models for Engineering Leaders

Introduction: It's Not Performance, It's Scalability

In engineering, we often chase performance, but the true challenge of growth lies in scalability. Wikipedia defines scalability as the capability of a system to handle a growing amount of work by adding resources to the system. This is fundamentally different from performance.

Performance measures the speed or latency of a single request—how fast one thing happens. Scalability measures the system's ability to handle an increasing volume of work—how well it maintains its effectiveness as the load grows.

Consider two algorithms. Algorithm 1 (blue line) has excellent initial performance, processing requests quickly under a light load. However, as the load increases, its throughput hits a hard ceiling. Algorithm 2 (red line) starts with lower performance but scales linearly. As the investment of resources or load increases, its throughput continues to rise steadily.

While Algorithm 1 is faster out of the gate, Algorithm 2 is far more scalable. It is the system you want for the long term. This article explores five mental models to help you understand and design for scalability in both your technical systems and your human teams.

The Ideal World: Linear Scalability

Linear scalability is the theoretical ideal. In this perfect world, throughput increases in direct, linear proportion to the resources you add.

  • In Systems: If one database node handles 100 operations per second, adding three more nodes would result in a system that perfectly handles 400 operations per second.
  • In Teams: If a two-person team has a certain capacity, adding two more people would instantly double the team's output.

However, true linear scalability is a myth: it's the stuff of bedtime stories. It assumes 100% efficiency and zero overhead from coordination or shared resources, a condition that never exists in the real world. This fiction provides a useful baseline, but to build effective systems, we must understand why it fails.

The First Bottleneck: Amdahl's Law and the Contention Factor

Amdahl's Law provides the first dose of reality. It introduces the contention factor (α), which represents the portion of a system or process that is inherently serial and cannot be parallelized. This is the part of the workload that creates a queue for a shared resource—the bottleneck.

As you add more resources (like CPUs or team members), the work gets done faster, but only up to a point. The serial, non-parallelizable portion eventually dominates, and the system's throughput levels off, approaching a hard limit or asymptote.

The key takeaway from Amdahl's Law is that the maximum theoretical speedup is limited by this serial portion, defined as 1/α.

  • If just 1% of a process is serial (α = 0.01), you can never make it more than 100x faster, no matter how many resources you throw at it.
  • If 5% is serial (α = 0.05), your maximum speedup is capped at 20x.

Examples of contention are everywhere:

  • In Teams:
    • If you have a specialized team for deployments and operations, you create a bottleneck for all the other teams.
    • Critical tasks like database migrations or specific pull request approvals that could only be done by one or two people created queues and immense pressure on those individuals. These knowledge silos are classic examples of contention.
  • In Systems:
    • A monolithic infrastructure where all processes must compete for the same limited pool of computing resources.
    • Heavy optimization processes where certain calculation steps are inherently sequential, limiting the benefits of adding more parallel workers.

The Hidden Tax: The Universal Scalability Law (USL) and the Coherence Factor

The Universal Scalability Law (USL) builds on Amdahl's Law by introducing a second, more insidious factor: the coherence factor (β). This represents the cost of coordination: the overhead required for parallel processes to communicate and maintain a consistent, shared view of the system. It's the time spent "getting on the same page."

The critical insight of USL is that after a certain point, adding more resources can actually make the system slower. The graph of throughput no longer just flattens out; it peaks and then begins to decline.

This happens because the coordination overhead grows quadratically. The number of potential communication pathways between N workers is N*(N-1). As you add more nodes or people, the cost of keeping everyone in sync explodes, eventually outweighing the benefit of the extra workers.

Examples of coherence costs include:

  • In Teams:
    • Very large teams where decision-making requires consensus from everyone, leading to endless meetings and slowing down progress.
    • High levels of dependencies between teams that force constant coordination and block work from being completed independently.
    • It's often said that to scale, we need to communicate better. This is true, but counter-intuitively, it often means communicating less. The goal isn't more meetings, but rather to establish shared context, clear principles, and a strong culture so that less ad-hoc communication is needed. This reduces the coherence penalty and allows teams to operate more autonomously.
  • In Systems:
    • The Nextail BI Subsystem provided a powerful lesson in avoiding coherence costs. To calculate a specific metric, two independent, parallel processes each needed the result of a shared computation. The surprising lesson was that it was more scalable to have each process perform the exact same calculation independently—duplicating work—than to incur the quadratic communication penalty required to coordinate and share the result.

The Peril of 100% Busy: Insights from Queueing Theory

Queueing Theory provides a model for understanding wait times and the impact of system utilization. Its core lesson is stark: as a system's utilization pushes past approximately 80%, the wait time for new tasks increases exponentially.

This behavior creates three distinct regimes of system health:

  1. Everything is okay: At low utilization, the system is responsive.
  2. Oh wait...: As utilization approaches the "knee" of the curve, delays become noticeable.
  3. F**k: At high utilization, the system collapses, and wait times approach infinity.

This degradation is made drastically worse by variability. The curve for high-variability systems (the blue line in the graph below) shows that wait times begin to explode at a much lower utilization threshold (e.g., 40-50%) compared to low-variability systems (the green line). A queue that handles a mix of very short tasks (2 minutes) and very long tasks (2 hours) will collapse much sooner. A 2-minute job stuck behind a 2-hour job creates an unacceptable experience.

Practical applications of this theory include:

  • In Teams: The anti-pattern of a centralized Operations Team that becomes a single, high-variability queue for all other development teams is a recipe for bottlenecks. A better model is to embed operations capabilities within each team, making them self-sufficient. Similarly, organizing teams end-to-end (e.g., by product feature) instead of by technology (front-end vs. back-end) creates self-sufficient units that don't need to queue up for another team to finish their work.
  • In Systems: Moving from a single job queue (monoqueue) to multiple, specialized queues is a common strategy. By separating long-running jobs from short, interactive ones, you reduce the variability within any single queue, ensuring that quick tasks aren't starved by resource-intensive ones.

To Go Faster, Slow Down: Little's Law

The final mental model, Little's Law, offers a simple but profound relationship between throughput, work-in-progress, and completion time. The formula is:

Lead Time = Work in Progress (WIP) / Throughput

  • Lead Time: The average time it takes for a task to be completed.
  • Work in Progress (WIP): The number of tasks being worked on simultaneously.
  • Throughput: The average rate at which tasks are completed.

The counter-intuitive implication is powerful: for a given team or system throughput, the only way to reduce the average time it takes to complete a task (Lead Time) is to reduce the number of tasks being worked on at the same time (WIP). To go faster, you must start less and finish more.

Practical applications of Little's Law include:

  • Teams/Processes:
  • Set explicit and low WIP limits to force teams to focus on finishing tasks before starting new ones.
  • Prioritize flow optimization (getting single items done quickly) over resource optimization (keeping everyone 100% busy).
  • Embrace practices like pair programming, which focuses the energy of two people on a single task. This is a direct application of flow optimization, designed to finish one piece of work much faster, thereby reducing the total WIP and shortening the overall lead time for features.
  • Build a self-service platform that empowers all teams to perform tasks like deployments or database migrations. This increases the entire organization's throughput without creating a centralized bottleneck team.

Conclusion: From Theory to Practice

These five mental models (Linear Scalability, Amdahl's Law, USL, Queueing Theory, and Little's Law) provide a powerful vocabulary for reasoning about growth. The goal isn't to memorize formulas, but to use these concepts to facilitate better conversations and design decisions.

A practical framework I find very useful for thinking about scalability is:

  • Design for 2x the current size or client load. This keeps the immediate solution robust.
  • Consider what 20x would require. Would the current architecture or technology still hold?
  • Brainstorm what 100x would mean. This exercise helps uncover fundamental limitations that may require a completely different approach in the future.

Ultimately, a core strategy for managing scale is to break down a large problem into smaller, independent subsystems. By doing so, you can keep each component operating in the "happy," efficient part of its scalability curve. This is a strategic trade-off: solving a scaling problem at one level intentionally creates a new, higher-level problem of coherence between those subsystems. But this is the fundamental and proven pattern for building systems and organizations that can gracefully handle growth.


Sunday, November 09, 2025

Pseudo TDD with AI

Exploring Test-Driven Development with AI Agents

Over the past few months, I've been experimenting with a way to apply Test-Driven Development (TDD) by leveraging artificial intelligence agents. The goal has been to maintain the essence of the TDD process (test, code, refactor) while taking advantage of the speed and code generation capabilities that AI offers. I call this approach Pseudo TDD with AI.

How the Process Works

The AI agent follows a set of simple rules:

  1. Write a test first.
  2. Run the test and verify that it fails.
  3. Write the production code.
  4. Run the tests again to verify that everything passes.

I use the rules I defined in my base setup for augmented coding with AI. With these base rules, I can get both the Cursor agent and Claude Code to perform the TDD loop almost completely autonomously.

The refactoring part is not included automatically. Instead, I request it periodically as I observe how the design evolves. This manual control allows me to adjust the design without slowing down the overall pace of work.

Confidence Level and Limitations

The level of confidence I have in the code generated through this process is somewhat lower than that of TDD done manually by an experienced developer. There are several reasons for this:

  • Sometimes the agent doesn't follow all the instructions exactly and skips a step.
  • It occasionally generates fewer tests than I would consider necessary to ensure good confidence in the code.
  • It tends to generalize too early, creating production code solutions that cover more cases than have actually been tested.

Despite these issues, the process is very efficient and the results are usually satisfactory. However, it still doesn't match the confidence level of fully human-driven TDD.

Supporting Tools

To compensate for these differences and increase confidence in the code, I rely on tools like Mutation Testing. This technique has proven very useful for detecting parts of the code that weren't adequately covered by tests, helping me strengthen the reliability of the process.

Alternative Approaches Explored

In the early phases of experimentation, I tried a different approach: directing the TDD process myself within the chat with the AI, step by step. It was a very controlled flow:

"Now I want a test for this."
"Now make it pass."
"Now refactor."

This method made the process practically equivalent to traditional human TDD, as I had complete control over every detail. However, it turned out to be slower and didn't really leverage the AI's capabilities. In practice, it worked more as occasional help than as an autonomous process.

Next Steps

From the current state of this Pseudo TDD with AI, I see two possible paths forward:

  1. Adjust the rules and processes so the flow comes closer to human TDD while maintaining AI speed.
  2. Keep the current approach while observing and measuring how closely it actually approximates a traditional TDD process.

In any case, I'll continue exploring and sharing any progress or learnings that emerge from this experiment. The goal is to keep searching for that balance point between efficiency and confidence that collaboration between humans and AI agents can offer.

Related Content