Orien Daly - The GHL University

This is where it starts to feel almost surreal.

You’re not just building systems anymore, you’re giving them a voice.

With tools like ElevenLabs, you can literally shape how your system sounds. Not just what it says, but how it says it.

Then you connect it through something like n8n using webhooks, so it can actually take action, not just talk.

And what I found interesting is… it’s not really about making it sound “cool.”

It’s about making it clear, natural, and intentional.
Something that feels human enough to trust, but structured enough to work.

Because at the end of the day, it’s not just a voice.

It’s a system that listens, responds, and actually gets things done.

.com

What really stands out to me here is how everything starts connecting.

It’s no longer just one automation doing one job.
You’re building a system where different pieces handle different roles.

One handles your CRM like GoHighLevel.
Another manages your calendar.
Another sends emails, texts… even makes calls.

And all of them can work together in one flow.

That’s when it shifts from “automation” to something closer to a system that actually operates.

You’re not doing each task anymore.
You’re designing how everything works together, and letting it run.

.com

This is where it starts to feel different.

You’re not just automating one task anymore.
You’re telling a system what you want… and it handles everything in between.

Update the lead.
Move them in the pipeline.
Reschedule the call.
Send the messages.

All in one flow.

Tools like GoHighLevel and systems built in Make make this possible.

And what’s interesting is… it starts to feel less like “automation”
and more like having something that just gets things done for you.

Not perfectly. But fast. And consistently.

That’s the shift.

.com

Something I had to learn early on…

An error message isn’t there to annoy you.
It’s there to tell you something didn’t go the way you expected.

That’s it.

When a workflow breaks inside Make, the system gives you a clue about where it went wrong.

And instead of ignoring it, you start reading it like a signal.

Because every error is just the system saying,
“this part didn’t work… go look here.”

Once you see it that way, debugging stops feeling frustrating.
It just becomes part of the process.

.com

This clicked for me in a really simple way.

An API is just how different apps talk to each other.
And the API key is what proves it’s actually you making that connection.

Think of it like a private key to your account.
Without it, nothing connects. With it, your systems can start working together.

So every time you connect something inside Make, you’re basically saying,
“hey, this is me, you’re allowed to access this.”

And once that’s in place, everything else flows.

.com

This is one of those small things that makes everything finally click.

When you’re building inside Make, every step (those little circles) holds information.

And as your workflow moves forward, each new step can look back and use anything that already happened.

It can pull from step 1, step 2… whatever’s already done.

But it can’t pull from the future.
Because it hasn’t happened yet.

Once I understood that, it became way clearer.

You’re not just connecting steps.
You’re building a timeline of data, and every step just references what already exists.

.com

One thing I learned the hard way…

Don’t jump straight into building.

Before I even open Make, I try to think about the end first.
What am I actually trying to make happen?

Because if you skip that part, you end up building halfway… then realizing you missed something important.

Sometimes I sketch it out.
Sometimes it’s just in my head.
Sometimes I start building and figure things out along the way.

But it’s always a mix of both.

You need a rough direction first… then you adjust as you go.

It’s kind of like building something from Lego.
You don’t always follow the instructions exactly, you take what’s there and shape it into what you actually want.

And the more you do it, the more you realize…

Good automations aren’t random.
They’re thought through, even if it’s just for a few minutes before you start.

.com

This was one of those things that changed how I use AI.

A prompt is just the input.
It’s what you tell the system, what context you give, how clear you are.

And everything after that depends on it.

Tools like ChatGPT or Claude aren’t “good” or “bad” on their own.
They’re only as useful as what you give them.

If the input is vague, the output will be vague.
If the input is clear and intentional, the output follows.

That’s why two people can use the same tool and get completely different results.

At some point, you realize it’s not really about the AI anymore.

It’s about how well you can think… and how well you can communicate that thinking.

.com

Something I started realizing is there isn’t just “one AI.”

You’ve got tools like ChatGPT, Claude, and Gemini, and they all do similar things, but in slightly different ways.

At first, I thought it was about picking the “best” one.

But it’s not really like that.

It’s more about what you need it for.

Sometimes you care about speed.
Sometimes it’s how accurate it is.
Sometimes it’s how consistent the responses feel.

Like with voice AI, speed matters a lot more.
Because even a small delay feels off in a real conversation.

So the real shift is this.

You stop asking “what’s the best AI?”
And start asking “what works best for this specific use case?”

.com

Something that really made it click for me.

In Make, they call it a “scenario,” but it’s really just your automation, your way of telling the system what should happen without you being there.

It’s like putting your thinking into a flow.
These are the steps. This is what happens first, next, and after.

And once it’s set, it just runs.

That’s when it shifts.

You’re no longer just doing the work yourself.
You’re building something that can do it for you, over and over again

.com