AI literacy may help us use today’s systems. Futures literacy may determine whether we are prepared for what those systems become.
The conversation around becoming “AI-ready” is moving remarkably fast.
A new model appears. A new coding assistant launches. Agents gain another capability. Organizations respond by asking people to learn the latest interface, prompting technique, automation workflow, or AI tool.
These skills matter.
But through my work in AI education and professional learning, I increasingly feel that we are confusing familiarity with today's AI with preparedness for the transformation AI may create.
A developer can become extremely proficient with today's AI stack and still be poorly prepared for what comes next.
Models will change. Interfaces will change. Agents will become more capable. Development workflows will change.
Some tasks developers perform today may become heavily automated, while entirely new responsibilities emerge.
So perhaps the deeper question is not:
How do we teach developers to use the current generation of AI?
It is:
How do we prepare developers for technologies that will keep changing?
My answer increasingly involves a capability that is rarely included in technical training:
Futures literacy
The AI-readiness mistake I keep seeing
Through teaching AI, working with students, and engaging with professionals, I keep seeing the same pattern.
People initially approach AI as a productivity tool.
The questions are usually familiar:
- Which AI tool should I learn?
- Which prompt should I use?
- Which model is better?
- How can I automate this task?
- How can AI make me faster?
These are valid questions.
But they are usually too narrow.
People become excited very quickly when they discover that generative AI can summarize documents, analyze information, create presentations, write code, generate images, or automate workflows.
That excitement can create a false sense of preparedness.
Knowing how to generate code with AI does not necessarily mean we understand the consequences of delegating technical judgment to AI.
Knowing how to build an agent does not automatically mean we understand how much authority that agent should have.
And knowing how to automate something does not necessarily mean it should be automated.
The recurring mistake is this:
Organizations often train people for the current interface rather than preparing them for technological uncertainty.
This is why I increasingly see AI literacy as a baseline, not a destination.
AI literacy helps us understand and work with artificial intelligence.
Futures literacy helps us ask what those systems may become, what assumptions we are making about them, what consequences they may produce, and what futures we are helping to create.
Put differently:
Prompting is an interface skill. Foresight is an adaptive capability.
Agentic AI changes the conversation
This becomes particularly important as we move toward agentic AI.
Traditional generative AI usually operates within a relatively simple relationship:
A person asks → the system responds → the person decides what happens next.
Agentic systems complicate this relationship.
An AI agent may be able to break a goal into tasks, choose tools, interact with external systems, retain information, make intermediate decisions, coordinate activities, and continue operating with limited human intervention.
The important shift is from assistance to delegation.
For developers, the technical question can no longer simply be:
Can we build an agent that works?
We also need to ask:
- What authority should it have?
- What systems can it access?
- What actions can it execute without approval?
- Which decisions should always remain human?
- How observable are its actions?
- Can its decisions be reversed?
- Who becomes accountable when something goes wrong?
- What happens when several autonomous systems interact with one another?
These are no longer peripheral questions.
They are increasingly becoming architecture questions.
A permission level is a governance decision.
A memory layer is a governance decision.
An escalation rule is a governance decision.
A human-in-the-loop mechanism is a governance decision.
Even deciding when an AI system should stop and request human intervention is a decision about how power is distributed between humans and machines.
Developers may therefore increasingly become designers of decision environments, not only writers of software.
What futures literacy means for a developer
Futures literacy does not mean predicting the future correctly.
The future is not one predetermined destination waiting to be discovered.
There are plausible futures, preferable futures, undesirable futures, and possibilities that may not yet be obvious to us.
For developers, this can become extremely practical.
Before building a feature, workflow, or AI agent, a team might ask:
What future are we assuming will exist if this system succeeds?
Then go further.
- What user behavior are we taking for granted?
- What could change technically, socially, economically, or legally?
- Who benefits if this system scales?
- Who might become more dependent on it?
- Who could be excluded?
- What new forms of monitoring or control could emerge?
- What second-order effects might appear after widespread adoption?
This moves the developer mindset through three levels:
- Does it work?
This is the traditional engineering question.
It remains essential.
- What happens if it works at scale?
A system used by 100 people and one used by 100 million people are not socially equivalent.
Scale can transform inconvenience into systemic risk.
- What kind of future does this make more likely?
This is where foresight enters engineering.
Every technology enables some behaviors, discourages others, creates dependencies, and redistributes certain forms of power.
It changes what becomes easier, harder, visible, invisible, normal, or expected.
Futures literacy helps developers explore those consequences while design choices are still available.
Five questions before deploying an AI agent
If a development or product team were preparing to deploy an AI agent tomorrow, I would encourage them to pause before becoming impressed by its technical capabilities.
I would examine five areas.
- Purpose
What problem are we actually trying to solve?
Does autonomy genuinely improve the solution?
Sometimes we introduce AI agency because the technology allows us to, rather than because autonomy is necessary.
The ability to automate something should not automatically become the justification for automating it.
Authority
What exactly can the agent do independently?
Can it send communications, modify data, execute code, spend money, approve transactions, interact with customers, or influence consequential decisions?
Authority should be designed deliberately.
The important question is not simply how capable the agent is.
It is:
How much capability should translate into permission?
Uncertainty
What assumptions are embedded in the system?
We may be assuming that the model will behave consistently, users will behave predictably, regulation will remain stable, external APIs will remain available, data will remain reliable, or human supervisors will intervene when needed.
Any of these assumptions can fail.
Foresight encourages teams to make those assumptions visible before they become invisible dependencies.
- System effects
What happens when the system operates repeatedly?
One automated action may appear harmless.
The same action performed 10,000 times may produce a very different outcome.
What happens if thousands of agents behave similarly?
What happens when agents interact with other agents?
What incentives emerge?
What dependencies are created?
The behavior of an entire system may be significantly different from the behavior of any individual component.
- Exit and accountability
Can a human understand what happened?
Can someone intervene?
Can an action be reversed?
Is there an audit trail?
Who is responsible when the system causes harm?
Every autonomous system should have an answer to a very human question:
How do we regain control?
Test more than one future
Before deployment, I would encourage teams to imagine at least three futures.
The expected future
The system performs approximately as planned.
Users behave mostly as expected.
The business case works.
The success future
The technology becomes dramatically more successful than anticipated.
Adoption grows ten times faster than expected.
Can governance scale with it?
Can human oversight scale?
Do small ethical compromises become significant at massive adoption?
The failure future
An important assumption breaks.
The agent behaves unexpectedly.
Users exploit the system in an unforeseen way.
Regulation shifts.
A dependency disappears.
Another technology changes the operating environment.
Most software testing asks:
Does the system behave correctly under predefined conditions?
Foresight adds another question:
What if the conditions themselves change?
For agentic AI, that distinction may become increasingly important.
AI may change what makes developers valuable
There is understandable anxiety about AI and software development.
If AI can increasingly generate code, write tests, create documentation, identify bugs, refactor systems, and orchestrate parts of development, what happens to developers?
I do not think the most useful question is whether developers become less important.
I think AI will change what makes a developer valuable.
As execution becomes easier to automate, value increasingly moves toward capabilities that are harder to automate:
- problem framing
- judgment
- systems thinking
- domain understanding
- trade-off analysis
- communication
- ethical reasoning
- context
- foresight
This leads to a principle I increasingly believe:
The more execution becomes automated, the more valuable judgment becomes.
The strongest developers of the coming decade may therefore not simply be those who can produce code fastest.
They may be those who can identify better problems, understand larger systems, anticipate consequences, and decide where automation should stop.
I see three forms of literacy becoming increasingly interconnected:
Technical literacy — understanding what the system can do.
AI literacy — understanding how intelligent systems behave, fail, and interact with humans.
Futures literacy — understanding how those systems might transform the environments into which they are deployed.
As AI becomes increasingly capable of answering technical questions, human advantage may depend more heavily on knowing:
Which questions are worth asking?
Developers are already designing futures
Developers are not solely responsible for the consequences of technology.
Executives, product teams, policymakers, investors, organizations, users, and institutions all influence technological outcomes.
But developers are not neutral observers either.
Every technical system contains assumptions.
Assumptions about users.
Assumptions about privacy.
Assumptions about acceptable error.
Assumptions about efficiency.
Assumptions about access, risk, control, and human versus machine authority.
Eventually, those assumptions become embedded in infrastructure.
And infrastructure shapes behavior.
When developers build AI systems, they participate in decisions about what should be automated, what should remain human, which errors are acceptable, whose interests are prioritized, and how much agency should be transferred to machines.
These are technical decisions.
But they are also decisions about possible futures.
My concern is that the technology industry often examines consequences too late.
Ethics arrives after architecture.
Governance arrives after deployment.
Risk management arrives after adoption.
By then, many choices are already embedded in the system.
Futures literacy offers another possibility.
It asks us to examine assumptions and consequences earlier.
Not because every developer must become a professional futurist.
But because thinking beyond the immediate release cycle may increasingly become part of responsible engineering.
So perhaps the most important question before building the next intelligent system is not only:
Can we build this?
Nor even:
Should we build this?
It may be:
What future are we helping to make more probable by building it this way?
Futures literacy is not an abstract skill reserved for futurists.
In the age of agentic AI, it may become part of what responsible software development means.
Further Reading
For readers who want to explore these ideas further:
- UNESCO — Futures Literacy
- NIST — Artificial Intelligence Risk Management Framework (AI RMF)
- OECD — Principles on Artificial Intelligence
- UNESCO — Recommendation on the Ethics of Artificial Intelligence
About the Author
Dr. Salman Ahmed Khatani is a Futurist, Associate Professor, author, and Founder of Fiker Futures Academy.
His work focuses on strategic foresight, futures literacy, AI literacy, responsible AI, the future of work, and future-ready education.
He is the author of Designing Tomorrow.