When the Skill Soup Fails: Too Many Tools, Not Enough Glue

I have been pitching the skill soup for months. Combine narrow tools, let each do what it is good at, win. The thesis holds up. But sometimes it fails, and I want to be honest about when. Too many tools without enough glue is its own kind of complexity. Here is how that breaks.

The Failure Mode

Last month I tried to build a content pipeline that used seven different tools in sequence. Each individual tool worked. The overall pipeline was a nightmare. Every failure became an archaeology exercise: which tool failed, in what stage, with what input, leaving what state. I spent more time debugging glue code than I saved with the tools themselves.

Why It Failed

Three reasons:

1. Too many interfaces to maintain: every tool had its own auth, its own errors, its own logging format
2. Shared state was fragile: the pipeline assumed each stage completed fully before the next began
3. Debugging was expensive: reproducing a failure required re-running earlier stages I did not own

The skill soup is not free. Every tool you add is a dependency to version, a surface to monitor, a format to translate.

The Rule I Added

I now apply a friction budget to new pipelines. Each added tool costs one friction point. If the pipeline budget is three points, I cannot add a fourth tool without removing one.

friction_budget = 3
pipeline_cost = count_distinct_tools(pipeline)
if pipeline_cost > friction_budget:
    consolidate_or_cut()

That forced me to ask: do I really need a separate transcription service if the model can do it? Do I really need a separate vector store if the dataset fits in Dynamo? The answer was often no. The pipeline got shorter. Debugging got easier. Shipping got faster.

When It Is Worth It

Multi-tool pipelines are worth it when each tool is dramatically better at its job than any generalist. Whisper for transcription. Claude for reasoning. Postgres for relational data. Those are specialists. You pay the integration cost because the specialist saves more work than the integration creates.

When the specialists are marginally better, consolidate. Two decent tools well-integrated ship more than five great tools loosely glued. The soup is a means, not a goal.

See the Twelve-Factor App methodology for how to keep multi-tool systems sane.