Riding the wave of technological transformation — before it rides you.
Change doesn't ask for permission. It doesn't wait for you to finish reading the manual on the last thing that changed. It arrives, reshapes everything around you, and moves on — leaving you holding documentation for something that's already obsolete.
We are living through one of the most compressed periods of transformation in human history. And the uncomfortable truth? We don't have time to fully understand it.
Things Change. Always. That's the Deal.
Change is not new. Seasons change. Empires rise and fall. Languages evolve, die, and get replaced. The wheel, the printing press, electricity, the internet — each one arrived and rewired how humanity functioned.
But here's what is new: the speed.
Technology is now changing faster than our collective ability to understand it. We barely grasp the possibilities, limitations, and risks of one wave before the next one is already breaking. We don't fully understand large language models yet — and multi-agent systems are already being deployed in production. We haven't resolved the ethical implications of deepfakes — and real-time AI video generation is already here.
There is no finish line where we finally "get it." The course keeps changing mid-race.
We Don't Love Change. We Love New.
Here's a nuance worth sitting with: humans don't actually love change. Change is uncomfortable, disruptive, even threatening. What we love is novelty.
New gadget. New feature. New model. New release. That dopamine hit when something feels fresh and exciting — that's not logic. That's biology.
Neuroscience is clear on this. When the brain encounters something potentially rewarding, neurons in the ventral tegmental area (VTA) activate and release dopamine — the brain's primary "reward" neurotransmitter. That dopamine burst travels to the nucleus accumbens and sends a signal to the prefrontal cortex, the part of the brain responsible for decision-making and planning. (Brain Reward System, Simply Psychology)
In other words, the anticipation of something new triggers a reward response before your rational mind has had a chance to evaluate whether the new thing is actually good, safe, or worth it.
When this system is in full swing, executive brain regions like the prefrontal cortex can become suppressed, while deeper reward-tracking areas like the nucleus accumbens are overemphasised — meaning we can lose the ability to properly weigh consequences because the dopamine signal overrides more rational assessments. (Addictive Behaviors Restructure Your Brain's Dopamine System, Medium / AI_ML)
This is not a character flaw. It is a feature of being human. But it is something we should be aware of — especially when the thing triggering our dopamine is a new AI tool promising to change everything.
AI and the Long Arc of How We Record Thought
To understand where we are with AI, it helps to zoom all the way out.
Human beings have always searched for better ways to externalise thought — to get ideas out of our heads and into the world.
- Around 3400 BCE, the Sumerians developed cuneiform — pressing a reed stylus into wet clay tablets to create wedge-shaped marks. It was slow, physical, and permanent.
- Ink and papyrus gave way to faster, lighter writing. Then came the codex — the bound book.
- The printing press in the 1440s didn't just speed things up. It democratised the creation and distribution of knowledge in a way that reshuffled power across entire civilisations.
- Typewriters mechanised the act of writing. Computers digitised it. The keyboard became the universal interface for thought.
And now? We are at another inflection point.
We still use the keyboard — but increasingly, we are describing what we want written rather than writing it ourselves. The act of producing text is being abstracted away. Instead of pressing a key to produce a character, we are prompting a model to produce a document, a function, an argument, a strategy.
The analogy isn't perfect — a Sumerian scribe pressing clay had intent, craft, and judgment baked into every mark. We should be careful not to lose that judgment as we hand more of the execution to machines. But the direction of travel is clear: each era found a way to make the recording of thought faster, more scalable, and more accessible. AI is the latest step on that path — and arguably the most discontinuous one yet.
AI Is Not Just a Tool. It's a Driver.
Previous technologies augmented human effort. AI is beginning to substitute for it — at least in certain domains. Code gets written. Emails get drafted. Analyses get generated. Decisions get informed.
This creates a genuinely new set of questions:
What do we lose?
Craft. Deep comprehension. The slow-burn understanding that comes from struggling with a problem yourself. The junior developer who never has to debug anything may become the senior developer who doesn't understand why anything works.
What do we gain?
Speed. Accessibility. The ability for one person to do what previously required a team. Reduced barriers to entry. More time to focus on higher-order thinking — if we choose to use it that way.
Who decides the return on investment?
This is the question nobody is asking loudly enough. When AI writes your code, who owns the quality bar? When an agent ships a feature, who is accountable for what it does in production? The efficiency gains are real — but they don't distribute evenly, and the risks don't either. The developer, the team, the organisation, and ultimately the user all have skin in the game. The ROI calculation isn't just financial. It's about skill atrophy, dependency risk, and what happens when the model gets it confidently wrong.
Practical: Embracing the Change Without Losing the Plot
Understanding the shift is one thing. Operating effectively inside it is another. Here's how to engage with AI-driven development in a grounded, productive way.
Using Agents
An AI agent is a system that can take actions autonomously to complete a goal — not just answer a question, but execute a sequence of steps: reading files, writing code, running tests, calling APIs, and iterating based on results.
Where a standard chat interaction is a single exchange, an agent is a loop. You give it a goal; it works toward that goal across multiple steps, using tools along the way.
Agents are powerful precisely because of that autonomy — and risky for exactly the same reason. A well-scoped agent with the right tools and guardrails is enormously productive. A poorly scoped one can make confident, cascading mistakes.
Tools: Claude Code, Codex, OpenCode and Others
The agentic coding landscape is growing fast. A few of the key players:
- Claude Code (Anthropic) — A command-line agentic coding tool that operates in your terminal, reads your codebase, writes and edits files, runs tests, and interacts with git. It is designed to work on real engineering tasks with full project context.
- Codex (OpenAI) — OpenAI's coding-focused model, now powering a cloud-based agent that can work on tasks in an isolated sandbox environment.
- OpenCode — An open-source, terminal-based AI coding assistant that supports multiple LLM backends. Lightweight, flexible, and designed for developers who want control over their tooling.
These are not autocomplete tools. They are systems that can reason about your codebase and act on it.
Understanding these concepts is one thing — but the best way to internalise them is to actually get your hands dirty. The tools available today are more accessible than they've ever been, and you don't need to architect a full multi-agent system to start benefiting from agentic workflows. The smartest move is to start small: pick one tool, get it running in a real project, and observe how it reasons. Build your intuition before you build your pipeline. With that in mind, let's walk through setting up OpenCode — one of the most developer-friendly entry points into agentic coding. It's open-source, runs in your terminal, supports multiple LLM backends, and gets you from zero to agentic in under five minutes.
Let's Build: Your First Agentic Setup
Prerequisites
- Node.js 18 or higher
- An API key for at least one supported LLM provider (Anthropic, OpenAI, etc.)
Step 1: Install OpenCode
npm install -g opencode-ai
Step 2: Configure your API key
OpenCode uses environment variables for authentication. Set your preferred provider:
# For Anthropic (Claude)
export ANTHROPIC_API_KEY=your_api_key_here
# For OpenAI
export OPENAI_API_KEY=your_api_key_here
You can add these to your .bashrc, .zshrc, or equivalent shell config to persist them.
Step 3: Launch OpenCode in your project
Navigate to your project directory and run:
cd your-project
opencode
This opens the interactive TUI (terminal user interface) inside your project context.
Step 4: Configure your model (optional)
OpenCode supports a config file (opencode.json or via the TUI settings) where you can specify:
- Your preferred model (e.g.,
claude-sonnet-4-5,gpt-4o) - Context window behaviour
- Tool permissions (file reads, shell execution, etc.)
Step 5: Give it a task
Inside the TUI, describe what you want done in plain language:
Add input validation to the user registration form and write tests for it.
OpenCode will read your codebase, propose a plan, and — with your approval — execute it.
Tips for working with OpenCode effectively:
- Be specific about scope. "Fix the authentication module" is worse than "Fix the JWT expiry bug in
auth/token.js." - Review every diff before approving. Agents can be confidently wrong.
- Use it iteratively. Small, focused tasks outperform large, vague ones.
- Keep your repo clean before starting. Agents work better with clear git history.
Something Else Worth Looking Into: Orchestrators
Once you've spent some time with a single agentic tool and you're comfortable with how agents reason and act, there's a natural next question: what happens when one agent isn't enough?
That's where orchestrators come in — and it's a rabbit hole worth going down when you're ready.
An orchestrator is the layer that coordinates multiple agents, tools, or models to accomplish a complex task. A single agent is a specialist. An orchestrator is the manager — breaking large goals into subtasks, delegating to the right agents, handling failures, and synthesising everything into a result.
It's a step up in complexity, but also a step up in what becomes possible. Frameworks like LangChain, LangGraph, CrewAI, and AutoGen are popular starting points. Anthropic's documentation also covers orchestration patterns using Claude as a directing model over a set of specialised sub-agents.
The key principle to carry with you: the orchestrator doesn't do the work. It coordinates who does.
It's not something you need on day one. But once single-agent workflows start feeling like a limitation, you'll know it's time.
Conclusion
Change is not coming. Change is already here, already reshaping what it means to write software, create content, and solve problems. The question is never whether to adapt — it's how to adapt with intention.
The developers and teams that will thrive are not the ones who adopt every new tool reflexively — chasing that dopamine hit of novelty — nor the ones who resist change out of comfort. They are the ones who engage critically: understanding what they gain, naming what they risk losing, asking hard questions about accountability, and then building deliberately with the best tools available.
The arc from clay tablet to keyboard to AI agent is long. We are privileged to be standing at one of its most remarkable bends.
Don't fear the current. Learn to navigate it. The future belongs to those who stay curious, stay critical, and keep building.
#AIChange #FutureOfCoding #AgenticAI #TechEvolution #DeveloperTools
Image: Photo by Ryoji Iwata on Unsplash
Top comments (0)