Systems
When Building with AI, Start With the Impossible Version
Don't ask what you can automate. Describe the system you wish existed, then work backward until you know how to build it.
By Mohanad Anan 9 min read
In this essay · 7 sections
- 01 Start With the Impossible
- 02 The Technology Isn’t Always the Limitation. Our Thinking Is.
- 03 Turn the Impossible Into a Set of Problems
- 04 Human Judgment Is Often Less Mysterious Than We Think
- 05 Context Is Becoming Part of the Architecture
- 06 Stop Automating Tasks. Start Architecting Outcomes.
- 07 So, How Do You Actually Apply This?
I think one of the biggest mistakes people make when building systems with AI is that they start by asking the wrong question.
“What can I automate?”
It sounds like a perfectly reasonable question. After all, automation is about saving time, reducing manual work, and making processes more efficient.
But I believe this question limits our imagination before we’ve even started.
Because the moment you ask what you can automate, you’re already assuming that the existing process is the right process. You’re simply looking for ways to make it faster, cheaper, or less dependent on humans.
But what if the entire process is fundamentally outdated?
What if, instead of automating the way things currently work, we could completely rethink how they should work?
That’s the mental shift I’m talking about.
Start With the Impossible
Whenever I think about building a new system, whether it’s for my business, an internal workflow, or a product, I try to start with a different question:
“What would the absolute perfect version of this system look like if it had human-level intelligence, unlimited patience, and could operate completely autonomously?”
Not the version I know how to build today.
Not the version that fits within my current technical knowledge.
And certainly not the version that simply replaces a few repetitive tasks.
I’m talking about the almost absurdly ambitious version.
A system that understands context. That makes intelligent decisions. That recognizes when something goes wrong and figures out what to do next. That learns from feedback, handles exceptions, and consistently produces the outcome I’m looking for.
A system where I don’t have to constantly tell it what to do, because it already understands what it’s supposed to achieve.
Now, I know what you might be thinking.
Sure, that sounds wonderful. But we can’t just build whatever we imagine.
And that’s exactly where I think the interesting part begins.
The Technology Isn’t Always the Limitation. Our Thinking Is.
For decades, we’ve been conditioned to think about software in a very particular way.
We define rules. We build workflows. We connect inputs to outputs. We tell computers exactly what to do, and when something requires judgment, we insert a human into the process.
That’s how traditional software works, and for a very long time, it made perfect sense.
But AI changes something fundamental.
Intelligence, or at least increasingly capable forms of reasoning and judgment, can now become a component of software itself.
Yet we’re still designing many of our systems as if that weren’t the case.
We take an existing workflow, identify a few steps that an LLM could perform, insert an AI call somewhere in the middle, and call it an AI-powered system.
And sometimes, that’s genuinely useful.
But I think we’re missing a much bigger opportunity.
We’re using exponential technology while still thinking linearly.
Imagine designing a modern car factory, but insisting that every production step must follow the exact same process workers used a hundred years ago.
You could introduce robots to replace individual workers, and the factory would certainly become more efficient.
But would that really be the best factory you could build with today’s technology?
Probably not.
You would redesign the factory itself around what the technology makes possible.
And I believe we should approach AI systems in exactly the same way.
Turn the Impossible Into a Set of Problems
Here’s something I’ve started to notice.
A lot of things we describe as impossible aren’t necessarily impossible.
They’re simply things we haven’t broken down far enough to understand.
When I imagine an autonomous system and encounter something that seems unrealistic, I try not to immediately lower my expectations.
Instead, I ask:
“Why not?”
Seriously. Why not?
What exactly is preventing this from working?
Is it a lack of information? Does the system need access to another tool? Does it need memory? Is there a decision that requires additional context? Is there a technical limitation, an economic constraint, or a reliability problem?
And perhaps my favorite question:
“This would be possible if… what?”
That question forces you to replace vague skepticism with something concrete.
And once you have a concrete problem, you can start thinking about solutions.
Of course, some limitations are real. AI can make mistakes, certain decisions require accountability, and full autonomy isn’t always safe or desirable.
But those should be conclusions you arrive at after investigating the problem, not assumptions you begin with.
There’s a massive difference between saying “AI can’t do that” and saying “AI could potentially do that, but it would require these five capabilities, and we currently only have four.”
The second statement gives you something to work with.
Human Judgment Is Often Less Mysterious Than We Think
One of the most interesting parts of building AI systems, at least for me, is investigating the moments where we automatically assume that a human is necessary.
Think about a skilled employee making a decision.
They look at information, evaluate different factors, compare possible outcomes, consider exceptions, and eventually choose what to do.
We call that experience, intuition, or professional judgment.
And often, rightly so.
But have you ever tried to reverse-engineer that judgment?
What information is the person actually looking at?
What makes them prefer option A over option B?
What would immediately disqualify an option?
What exceptions would cause them to change their decision?
What does an excellent result look like compared to an average one?
The more you investigate, the more you realize that a surprising amount of what we call judgment can be articulated as decision principles.
Not necessarily simple rules, but combinations of context, priorities, constraints, examples, exceptions, and trade-offs.
In a way, much of it resembles incredibly sophisticated if/else logic, expressed in natural language.
And that’s fascinating.
Because we now have systems that can interpret natural-language instructions, reason over information, use tools, and apply those principles to situations they’ve never encountered before.
That doesn’t mean every human decision can or should be automated.
But it does mean we should stop treating every decision that involves judgment as automatically impossible to delegate.
Sometimes the missing piece isn’t a more intelligent model. It’s a better explanation of what good judgment actually looks like.
Context Is Becoming Part of the Architecture
This leads to something I believe is going to become increasingly important:
The quality of an AI-powered system isn’t determined only by how intelligent its underlying model is.
It’s also determined by how well the system understands the world it’s operating in.
Its objectives. Its constraints. Its tools. Its standards. Its history. Its definition of success.
In traditional software, we spend enormous amounts of effort explicitly programming behavior.
In AI-native systems, we can increasingly spend that effort engineering the context within which intelligent behavior happens.
That context might live in Markdown files, agent skills, system instructions, structured databases, examples, tools, or feedback mechanisms.
The format isn’t really the point.
The point is that you’re building an environment where intelligence can operate consistently and purposefully.
And the better that environment becomes, the less you need to micromanage every individual step.
I think of it as the difference between giving someone a list of instructions and building an organization where a capable employee understands their responsibilities, has access to the right information, knows what success looks like, and can make decisions independently.
The second approach is much more powerful.
And that’s exactly how I want to think about building systems.
Stop Automating Tasks. Start Architecting Outcomes.
This is probably the most important distinction.
Traditional automation starts with an existing process and asks:
“Which steps can software execute instead of a human?”
AI-native architecture asks something much more interesting:
“If intelligence itself were programmable, would this process even need to exist in its current form?”
Those are two completely different starting points.
One optimizes the existing system.
The other questions the system itself.
And I believe the second approach is where the biggest opportunities are.
Because ultimately, I don’t care whether my system performs 10 tasks or 100 tasks automatically.
I care whether it reliably produces the outcome I built it for.
If my goal is to find the best opportunities, I don’t want a system that simply automates the process of searching a few websites.
I want a system that understands what makes an opportunity excellent, searches comprehensively, evaluates alternatives, recognizes uncertainty, and continuously works toward finding the best possible matches.
Searching websites is just an implementation detail.
Finding the right opportunities is the outcome.
That’s the difference.
And once you begin thinking in outcomes rather than tasks, you start seeing entirely different ways to build things.
So, How Do You Actually Apply This?
I don’t think this needs to be complicated. The framework I use is relatively simple:
- Imagine the dream state. Describe the most capable, autonomous version of your system, without immediately filtering your ideas through today’s technical limitations. Focus on the outcome, not the workflow.
- Challenge every assumption. Whenever something sounds impossible, ask why. Identify exactly what’s missing, what could go wrong, and what would need to be true for it to work.
- Reverse-engineer human judgment. Identify the decisions people currently make, what information they rely on, how they evaluate options, and what separates a good decision from a bad one.
- Build the context and capabilities. Translate that knowledge into accessible instructions, skills, examples, tools, memory, and structured information. Give the system what it needs to make informed decisions rather than blindly follow steps.
- Design backward from the outcome. Build the architecture that makes the desired result possible. Introduce human review, validation, and safeguards wherever they’re genuinely needed, rather than automatically reproducing the old workflow.
- Improve the system through reality. Test it against real situations, study where its decisions fail, and improve its context, tools, and evaluation criteria. Autonomy should be earned through reliability, not simply declared in a prompt.
And that’s pretty much it.
The goal isn’t to blindly remove humans from every process or pretend that AI is capable of doing everything.
The goal is to stop letting yesterday’s limitations dictate tomorrow’s architecture.
I think we’re entering a period where one of the most valuable skills won’t simply be knowing how to automate something.
It will be knowing how to imagine, design, and orchestrate systems that would have been completely unrealistic only a few years ago.
And that starts with having the courage to describe the version that initially sounds impossible.
Don’t start with what you can automate. Start with what you wish existed. Then work backward until you know how to build it.
Mohanad
Düsseldorf, 31 October 2026