Why context beats competence (the AI delegation guide)
How to build a system where the person with the most information makes the decision instantly.
Welcome to issue #98 of FutureBrief. Every week I share practical insights on AI & automation trends, tools, and tutorials for business leaders. If you need support on your technological journey, join our community and get access to group chat, Q&As, worksheets, and templates.
Ninjabot delivers ready-to-deploy sales AI and automation tools that allows business operators to stop doing busywork and start managing leverage.
For the last couple of weeks, I’ve been obsessed with a single, uncomfortable question:
Who is actually better at the job? The expert with the technical skills, or the user with the business context?
A few months ago we launched a new product called AI Salesman. The journey of building, breaking, and rebuilding this product taught me a lesson about delegation that changed how I view business systems.
It forced me to confront a hard truth about my own ego as a builder.
I thought my value lay in my ability to control the machine. I thought clients paid me to be the Wizard of Oz, pulling levers behind a curtain to make the magic happen.
I was wrong.
The ultimate form of business art isn’t building a team of wizards. It’s building a machine so simple that the user can pull the levers themselves.
This is the story of how we fired ourselves as managers of AI to become architects.
And why giving up control was the only way to gain freedom.
Phase 1: The spaghetti
We didn’t start with a sleek SaaS platform. We started (like many scrappy operators) with digital duct tape.
To test product-market fit for AI Salesman, we used n8n, a low-code workflow automation tool. It was effective, but it was ugly. We were essentially hard-coding business logic into a visual spaghetti of nodes.
Client needs a price check? Build a specific branch in the workflow.
Client wants to change their tone from formal to casual? Pause the workflow, rewrite the system prompt, and restart the workflow.
I was operating at Level 1 of the Autonomy Spectrum – manual execution.
At this stage, me and our developers were essential. If I didn’t prepare the right architecture and our developers didn’t develop the solutions, the projects wouldn’t move on.
I was the bottleneck, but I knew this is just the first phase. The problem is, many founders get addicted to this phase. It feels like work. It feels like hustle. But it’s not a business. It’s a high-stress job with overhead.
We proved the concept (the AI could work as good as an average sales rep) but the operational cost was killing us. We were spending 80% of our time maintaining the wires and only 20% improving the product.
Phase 2: The internal tool
As we scaled to dozens of clients, the manual n8n workflows became unmanageable. We needed to delegate.
So, we did what many growing agencies do: We built an internal app to manage the implementations.
We’ve let developers build a robust backend where our internal team of consultants and prompt engineers could manage client accounts. We created a dashboard that allowed us to update vector databases, tweak temperature settings, prompts, and adjust conversation flows without touching raw code.
Now we were operating at Level 2 – delegated execution.
In this phase, we sold managed services. The client would pay a premium retainer, and we delivered a white glove support.
Client: “The AI is recommending a product that we stopped selling last week.”
Account Manager: “Understood. I’ll brief the engineering team.”
Engineer: Tweaks prompt.
Account Manager: “Fixed.”
We patted ourselves on the back.
We had systematized the chaos. We had SOPs (standard operating procedures). We had a team of experts managing the complex technology so the client didn’t have to.
But we had unknowingly walked into a trap.
By inserting ourselves as the experts in the middle, we had created a game of Telephone. Every piece of feedback from the market had to travel from the client, to the account manager, to the engineer, and finally to the AI.
Information was decaying at every hop.
We were competent, but we lacked context.
We didn’t know when clients stopped selling a product or updated their prices. We had to learn about this from them. We were optimizing for clean code, while the client needed to optimize for messy commerce.
Phase 3: The revelation
To scale further, we realized we couldn’t hire an account manager for every 10 new clients. The economics didn’t work. We had to remove the middleman.
We decided to take our internal tools, wrap them in a user-friendly design, and give the login credentials directly to the clients.
So we built a frontend app that sat on top of our complex backend. We gave clients access to AI salesman configuration and to manage their AI knowledge base. We gave them a text box to write their own system instructions.
This was Level 3 – infinite execution.
Honestly? We were scared.
We thought that without our expert sales coaching and prompt engineering skills, clients would break it. We thought they would be overwhelmed by the technology.
We assumed that the AI would start hallucinating and clients would leave.
We prepared our support team for a flood of “I broke it” tickets.
Instead, we saw something that hurt my ego but healed my business.
The clients started outperforming us.
We watched the data. A floor heating company wrote a system instruction that didn’t look like our best practice prompt engineering. But their AI agent started booking sales meetings at a higher rate than the one we had spent weeks fine-tuning.
Why?
Because they know specific nuances about floor heating inquiries and the communication style with their typical clients.
They know the context. We know the solution.
By giving him the right tool, we allowed them to inject their 20 years of experience directly into the system, without it getting diluted by our team’s expertise.
The hierarchy of autonomy
This journey forced me to look differently at delegation.
Most founders and operators view delegation as hiring people to do tasks. This is a limited view.
True delegation is about moving the locus of control and intelligence closer to the reality of the market.
Here is the Autonomy Spectrum every system builder should aim to climb:
Level 1: Manual execution
Who does the work: You.
The mechanism: Spaghetti code, manual emails, spreadsheets.
The limit: You run out of hours.
The result: You feel heroic but exhausted.
Level 2: Delegated execution
Who does the work: Your employees.
The mechanism: Internal tools, SOPs, meetings, approval chains.
The limit: Loss of signal. The Telephone game distorts reality. Costs scale linearly with revenue.
The result: You feel productive because you have a team, but you have actually just created a buffer between your business and the market.
Level 3: Infinite execution
Who does the work: The system and it’s user
The mechanism: Automations and AI with guardrails, direct feedback loops.
The limit: Technical debt (you must maintain the code).
The result: Context meets execution instantly. Infinite leverage.
The psychology of detachment
There is a philosophical, almost Stoic dimension to this transition.
Operating at Level 2 feeds the ego. It feels good to be the expert. It feels good to say, “Don’t worry client, we will handle the complex AI for you.” It validates your intelligence.
Moving to Level 3 requires humility. You have to admit that you are not the smartest person in the room regarding the application of your tool. You are just the builder of the hammer. The carpenter knows better how to swing it.
Code is the ultimate Stoic employee. It doesn’t have an opinion. It doesn’t try to prove it knows better than the user. It simply executes the logic it is given.
By building a Level 3 system, you are practicing the Stoic discipline of detachment. You are detaching your personal effort from the result.
In Phase 1, if a client failed, it was because I didn’t architect the workflow right.
In Phase 2, if a client failed, it was because my team didn’t manage the prompts well.
In Phase 3, the client owns their success. We provide the reliable infrastructure. They provide the business logic.
Context is the new currency
This lesson extends far beyond SaaS products or AI agents. It applies to how you run your internal teams.
How many times have you set up a system where a decision requires a manager's approval?
A refund over $50.
A blog post.
A slight change to a sales script.
Every time you do this, you are forcing your company back into Level 2. You are saying, “I trust my judgment (distant from the problem) more than your judgment (facing the problem).”
A stoic operator builds Level 3 systems for employees too.
Instead of requiring approval for a refund, you write code (guardrails): “Any support agent can issue a refund up to $100 without approval. If >$100, the system blocks it.”
Now, you have delegated authority to code. The support agent (who is on the phone with the angry customer and has the context) is empowered to solve the problem instantly. They don’t have to ask you. You don’t have to be interrupted.
You have replaced a manager with a rule.
From operator to architect
I don’t want to oversimplify. We didn’t fire everyone and leave our clients alone in the dark.
We still have clients who want us to manage the whole system. We still do onboarding packages where we help them prepare their data, structure their initial prompts, and set up the integrations.
But the dynamic has changed.
We are no longer the wizards hoarding the magic, forcing them to pay a monthly toll to access it. We are the architects.
We build the house, we check the wiring, we hand them the keys, and we say: “You know how to live here better than we do. But if the roof leaks, we are here.”
Code is the great democratizer
The ultimate delegation is not finding someone to do the work for you. It is building a system that empowers the person with the most context to do the work themselves, with zero friction.
By using code to build a user-friendly layer on top of complex technology, you can empower your team and clients to be your best prompt engineers.
If you are building a business, whether it’s an agency, a shop, or a tech company, ask yourself:
Are you building tools that make you feel essential? Or are you building systems that make your users powerful?
The former feeds your ego and starves your time. The latter feeds your bank account and gives you your freedom back.
Build the interface. Trust the frontline. Let the code do the heavy lifting.
— Yuri
🛠️ Builder’s vault
If you are a FutureBrief Premium member, in the Builder’s Vault you can find the Autonomy Spectrum Audit, which will help you identify where your business relies on heroics (Level 1) or bureaucracy (Level 2) and systematically move those processes to infinite execution (Level 3).
Forward this to a colleague who’s wrestling with manual processes. They’ll thank you.
What’s your take on today’s topics? Did you like it, or is there something I missed?
Building modern tech for SMBs? Reach 20,000+ decision-makers who are actively implementing AI, automation, and no-code tools. Become a sponsor.