Automation’s Real Job: Make Life Easier, Not Harder

In a previous post, I talked about why product adoption is, for me, the single most important factor in automation. And honestly, I see this play out every day with clients. Progress with Ansible often feels slow. Part of it is the learning curve, sure, but part of it comes from people trying to make their code “perfect” — technically elegant, clever, optimized. I get it. I’ve been there.

The tricky part? This sometimes creates friction between users who have programming experience and those who don’t. It slows things down and makes collaboration harder. Even as product vendors, whose main goal should be helping teams adopt tools smoothly, we sometimes unintentionally push customers toward the more complex pseudo-code route. I totally understand why — it looks neat on paper. But in practice, it can make learning harder and adoption slower. Keeping things simple often gets everyone on board faster.

And here’s another thing: even in the age of AI, when models can write code for us, we need to resist the temptation to lean on complexity. Sure, AI can generate clever solutions in seconds, but if it’s too convoluted, we lose control. We lose understanding. And if teams can’t maintain or trust the code, adoption suffers.

Finally, some practical realities: automation code can be is short-lived or not often used. So why spend hours perfecting something that might only exist for a few months or is only executed a few times per year? Simplicity usually gives you the most value for the least effort.

Why Simple Code Usually Wins

It Actually Gets Used

Let’s face it: fancy automation that only a few people can read might impress your peers, but it’s useless if nobody else dares touch it. Clean, predictable playbooks invite participation. Complicated ones? They scare people away.

It Builds a Community

When people can read the code, they’re more likely to fix typos, tweak tasks, or share improvements. Over time, automation stops being a project owned by one team and becomes something everyone contributes to — a real internal community.

It Reduces Risk

Every layer of complexity adds risk. It slows onboarding, makes code reviews harder, and leaves fewer people confident enough to make changes. The result? Fragile, expensive, stressful systems. That’s the exact opposite of what automation is supposed to do.

Complexity Isn’t Free — It Costs Money

Let’s talk dollars and cents. Complex code isn’t just a technical burden; it’s a financial one:

  • Training: New team members take longer to onboard.
  • Maintenance: Every update takes more time because fewer people understand it.
  • Lost efficiency: When teams don’t trust automation, they fall back to manual processes.
  • Higher risk: Bugs in complex logic are harder to find and fix, leading to costly outages.
  • Talent churn: If only a handful of people know the code and someone leaves, replacing them is expensive and disruptive.

The hidden costs add up fast. What starts as “clever optimization” can quickly become a liability.

When Complexity Makes Sense — And How to Handle It

Of course, there are exceptions. Maybe you’re processing massive inventories or datasets, or performance really matters. In those cases, a more complex solution can be justified. But even then, keep it contained:

  • Put complexity in one place.
  • Wrap it in a role, plugin, or module.
  • Give everyone else a clean, simple interface to interact with.

This way, your team can enjoy the benefits of optimization without making the system intimidating or fragile for the majority.

In any case, I recommend exploring the features of the Ansible Automation Platform tools (distributed inventories, job slicing, etc) to optimize executions instead of making complex code difficult to mantain.

Start Simple, Stay Trusted

The best way to grow automation? Start simple. Get people using it. Build trust. Only optimize when real pain points arise. Document as you go. Train those who need the deeper knowledge, but don’t force everyone to become a power user overnight.

This approach keeps automation empowering rather than intimidating. It ensures that your code is actually used, maintained, and built upon.

The Bottom Line

Good automation doesn’t try to impress. It quietly works, is easy to understand, and grows with the teams that use it. Keep it simple for as long as possible. Reach for complexity only when necessary — and when you do, hide it behind a clean, approachable interface.

At the end of the day, success isn’t measured in clever loops or perfect filters. It’s measured in how many people actually use the system, trust it, and contribute to it. That’s how a tool becomes a solution, and a solution becomes a thriving community.