The problem isn't the AI tools. Claude is good. ChatGPT is good. Perplexity, ElevenLabs, Whisper, all of it, good. The problem is the space between them.
Every tool wants to be its own island. You get a result in one place and then you're copy-pasting it somewhere else, reformatting it, feeding it into the next thing by hand. That's not a workflow. That's just manual labor with extra steps.
Make.com fixed that for me. Not perfectly, not magically, but practically. It's the connective tissue I use to wire tools together so a trigger in one place sets off a chain that runs without me touching it.
What I'm Actually Wiring Together
Before I get into the how, here's what a real scenario looks like in our setup.
A client fills out a form. That form submission triggers a Make scenario. The scenario pulls the form data, sends it to Claude via the Anthropic HTTP module, gets back a structured response, formats it, drops a summary into Notion, sends a Slack message with the key points, and logs everything to a Google Sheet for tracking.
That whole chain runs in under 30 seconds. Zero code. No glue scripts. No Lambda functions sitting in the middle hoping they don't time out.
That's the pitch. Now here's how it actually works.
Start With the HTTP Module, Not the Pre-Built Integrations
Make has pre-built modules for a lot of tools. Some of them are great. A lot of them are outdated or missing the parameters you actually need.
For AI tools specifically, I skip the pre-built modules and go straight to the HTTP module. You send a POST request to the API endpoint, you set your headers, you pass your JSON body. Done. You get full control over the model, the parameters, the prompt structure, everything.
This matters because when Anthropic ships a new model or a new parameter, you can use it immediately. You're not waiting for Make to update their Claude module. Same for OpenAI, same for any other API.
The learning curve is maybe 20 minutes the first time. After that it's faster than messing with pre-built modules that don't quite do what you need.
Structure Your Prompts in the Scenario, Not Hardcoded
One mistake I see constantly: people hardcode their prompts into the HTTP body as a static string. That works until it doesn't, and then debugging it is a nightmare.
Instead, use Make's text aggregator or a Set Variable module to build your prompt dynamically before you hit the AI endpoint. Pull in values from earlier in the scenario. User's name, form data, context from a previous module, whatever you need.
This gives you a readable prompt in one place that you can actually update without digging through a JSON body buried inside an HTTP module. It's also easier to version and debug when something goes wrong.
Parse the Response Before You Use It
AI APIs return JSON. Inside that JSON is usually a content field, inside that is the actual text. If you try to pass the raw response directly to the next module, things break in weird ways.
Add a Parse JSON module right after your HTTP call. Map the response body into it. Now you can reference specific fields cleanly in every module that follows. The output text becomes a proper variable, not a string you have to manually navigate.
If the AI is returning structured data, like a JSON object you asked it to format, you'll want to do a second parse on the content field itself. Ask the AI to return valid JSON, then parse it again in Make so you get actual mapped fields instead of a raw string.
Handle Errors or Your Scenario Will Silently Die
Make scenarios fail silently by default. You run it, nothing happens downstream, and you have no idea why unless you go digging through execution logs.
Set up error handling on your HTTP modules. Make has a built-in error handler you can attach to any module. At minimum, route errors to a Slack message or an email so you know when something breaks. For production workflows, log the error details somewhere you can actually read them.
Also set retries on your HTTP modules. AI APIs rate limit. They time out occasionally. A simple retry with a delay handles 90 percent of transient failures without you having to do anything.
Chain Multiple AI Calls Without Burning Your Budget
Some workflows need more than one AI call. You might generate something with one prompt, then pass that output into a second prompt for refinement or classification or summarization.
This is totally fine, but be deliberate about it. Every chained call costs tokens. Use smaller, faster models for classification tasks and save the heavier models for generation. Claude Haiku for routing decisions, Claude Sonnet for actual content. GPT-4o-mini for quick extractions, GPT-4o for the heavy lift.
You can set this up in Make by just chaining HTTP modules, one after the other, with the output of each feeding into the next. The scenario handles the sequencing. You just map the right fields.
If you want the exact scenario structure we start from and how we keep prompts out of Make entirely, that's in Inner Circle along with the full routing pattern we use for conditional AI workflows.
Keep building
- Dead Code Path Tracer from the prompt library
- Dead Code Path Tracer from the prompt library
- How I Delegate to Named Operators Without Hiring Anyone
- The full Vaylo prompt library, new drops weekly
