Note: The date is important because my thoughts change very frequently as things are moving so fast, so anything you read here is a snapshot of time in mid-2025.
I've been an early adopter of AI tools and have been so busy adapting how I work that I haven't had a chance to write about it. But now here we are, and I wanted to share my perspectives on the rapidly evolving technology landscape.
My Background
For context, I've been professionally building software for over 20 years and managing technical teams for a large part of that time. My experience spans government, large enterprise, small business, startups, and solo side projects. I've built everything from native apps and web applications to large-scale integrations, cloud infrastructure, server-side systems, and more recently, AI-powered solutions.
Throughout this journey, one trait has served me better than any technical skill: curiosity. The willingness to ask "why" and "how" has consistently opened doors to deeper understanding and better solutions. I've found that the most effective engineers aren't necessarily those who memorise the most APIs or algorithms, but those who approach problems with genuine curiosity about the underlying needs and contexts.
My journey into a software engineer/developer role wasn't just the traditional computer science degree path that many follow. My first real experience writing code was in the early 90s, building fan websites for bands on Geocities. I had to learn some HTML to get things looking right on the web page. This knowledge evolved into building more custom websites for my actual band, where I experimented with early versions of JavaScript to create hide/show functionality.
I then lost interest for a while as I went through the end of high school and university, where I completed a Bachelor of IT majoring in 'Information Systems' (not 'Software Development'). My focus wasn't on programming but on data, databases, and information systems. My first paid role as an IT professional was testing web applications. As I logged bugs related to HTML, CSS, or JS (front-end issues), I would include what I thought was the fix in the bug ticket. Eventually, the engineering manager noticed this pattern and asked, "Do you want to join the development team?" And so began my career in software development.
Evolution into Leadership
I took on leadership roles fairly early in my career. This wasn't because I was desperate to manage people, but because when I saw things could be improved, I wouldn't just wait for permission to fix them. I would find ways to make change happen and get teams to address issues rather than expecting management to solve everything.
I've taken this approach throughout my career. Regardless of my job title, if there are problems to be solved (whether people problems or technical problems), I thrive on the problem-solving process. I enjoy experimenting, learning, and continuously improving.
So when I'm building software, I'm generally not looking at it from the perspective of "I love writing code." I simply love solving problems, and more importantly, making sure I'm solving the right problems. Since I developed the skillset to solve problems with code and technical solutions, that's generally what I've been doing alongside my management roles. The curious mindset of asking "Is this actually the problem we need to solve?" has saved countless hours that might have been spent building elegant solutions to the wrong problems.
The Emergence of AI Tools and "Vibe Coding"
This brings me to AI tools and what some are calling "Vibe Coding." The term was coined by Andrej Karpathy in February 2025 to describe a coding approach where you describe what you want in natural language and let AI tools generate the implementation details.
I heard a good analogy recently about video cameras that I'd like to expand on here:
When video cameras first appeared, there was no such thing as a "video editor" job. Then professionals emerged who became really skilled at editing videos. Later, software was developed to make video editing easier, enabling professionals to produce higher-quality video content than before they had these tools.
Fast forward to today: there are still professionals who excel at video editing, working in the film industry, creating incredible movies. But simultaneously, anyone with a smartphone and basic software can produce fairly professional videos, upload them to YouTube or TikTok, and build a business around that content. They don't necessarily need to pay a professional to do this. However, if they were asked to collaborate on a video destined for a feature film, they might seek assistance from a professional video editor.
The Software Development Parallel
If we apply this analogy to software development, we can trace a similar trajectory. Back when people were building software on punch cards, becoming a programmer wasn't a very accessible career option. You can fast-forward through time and observe how it has evolved, from assembly language to higher-level languages. We continually abstract away the lower-level details and build on top to solve more problems faster, without spending time on mundane, low-level work.
This evolution means software development has become "easier," enabling more people to build things with less training or specialised knowledge. This is the trajectory we're on. The only difference now is that the speed at which AI tools are evolving is far faster than anything else in history in terms of capability development over time.
Concerns About the Future of Development
I speak with developers who are concerned about their careers, and that's absolutely fair. If you view your career as "writing beautiful, well-crafted code," then I think that will become a dying art over time. However, if you see your job as being a problem solver, using tools to address challenges in the best way possible in a manner that makes people happy, then your job is very secure.
Even though these AI tools are evolving rapidly, it doesn't mean everyone will want to use them. We will still have people who want to say, "Hey, I've got this problem, help me solve it," and no matter how good AI gets at that, human empathy and intuition will always add value to the process.
Here's something important to consider: even if non-developers could theoretically build their own software with AI tools, many simply won't enjoy that process. They may want to throw vague requirements at someone and say, "make it work" without getting into the details. AI tools, no matter how sophisticated they become, may not ask the right clarifying questions or understand the nuanced context that a human would naturally explore.
Most end users want the feature, not the journey of building it. They don't necessarily enjoy troubleshooting issues, spending hours going down technical rabbit holes, or thinking deeply about system architecture and edge cases. When something breaks at 2 AM or when requirements turn out to be more complex than initially thought, they want someone who genuinely enjoys solving those problems to do that work.
As technology professionals, we often forget that not everyone finds debugging fascinating or gets satisfaction from finally tracking down that elusive bug after hours of investigation. That curiosity-driven problem-solving mindset, combined with the patience to work through complex technical challenges, remains distinctly valuable even in an AI-powered world.
My Recommendations
I would recommend that people still learn to code. Not just that, but approach technology with insatiable curiosity. Learn how computers work from the ground up. Ask questions about why systems are designed in certain ways. Be curious about everything at the lowest level possible and understand how it all works. This curiosity-driven approach will mean you can solve problems better than someone who doesn't have that knowledge or who simply implements solutions without questioning their foundations.
What will set you apart as a technology professional from a businessperson using Vibe Coding tools is your knowledge and understanding of how things work. You'll never learn how everything works, but you need to have a solid understanding of the layer below your level of abstraction.
Consider these examples: as a game developer, you can use tools and frameworks to get a 3D game up and running quickly. But if you have a solid understanding of how the underlying hardware works (CPU, RAM, GPU, storage), you can better troubleshoot performance issues and provide more effective prompts to AI tools for optimising game architecture. Your technical knowledge helps you ask better questions and recognise when AI suggestions might cause bottlenecks or not scale.
As a web developer, you can get a frontend deployed to production using AI-generated code. However, if you have a working knowledge of how networking and the internet actually function (DNS, IP addressing, firewalls, CDNs), you'll be far better equipped to troubleshoot deployment issues and guide AI tools toward solutions that work reliably at scale. You'll understand the implications of AI-suggested architecture decisions rather than blindly implementing them and running into issues down the track.
This foundational knowledge becomes your competitive advantage. When AI tools hit their limits or produce solutions that seem to work but have hidden problems, your understanding of the underlying systems allows you to step in and course-correct. You become the bridge between what AI can generate and what actually works in production.
As the old saying goes, "If all you have is a hammer, everything looks like a nail", so broaden your knowledge and understanding through persistent questioning. That curiosity will always be valuable and, if nothing else, should be fun as well! The most valuable engineers I know aren't just skilled coders. They're the ones who ask "Why are we building this?" before writing a single line of code, ensuring they're solving the right problem.
But perhaps don't spend too long trying to master tasks that other tools will eventually perform better than you, especially if you're hoping to get paid for it. Like an artist might enjoy painting for fun, you might enjoy writing code for fun. Great, go for it! But if you're being paid to solve problems, over time, the amount of code you may write will likely decrease. You might find yourself left behind because there are increasingly better ways to accomplish tasks.
The Reality of AI Tools in Mid-2025
I've been pondering the different perspectives on where AI development tools are heading. A colleague recently laid out four possible scenarios:
Option 1: The hype is all real. Knowledge workers, including developers, are largely replaced.
Option 2: The hype is close to real. You can generate entire apps "pretty easily" using LLMs, but you still need somebody who understands the fundamentals to guide the process.
Option 3: The hype isn't real, but the tools are useful. LLMs become part of our workflow like IDEs.
Option 4: AI doesn't advance beyond current capabilities and remains too expensive to run, making it uneconomical for many tasks.
From where I stand in mid-2025, we've clearly settled into Option 2 territory. The capabilities have matured significantly since the early part of this year, and there has been an explosion of agentic coding tools available.
Embracing "Context Engineering" Over "Vibe Coding"
As we navigate this evolving landscape, we need to refine our terminology. While vibe Coding works well for non-developers who want to describe what they want and get functional results, for professional developers, what we're really doing is Context Engineering.
The concept of "Context Engineering" was popularised by Shopify's CEO Tobi Lütke and Andrej Karpathy in mid-2025 as a more precise descriptor for the sophisticated work of building effective AI systems.
Context Engineering involves providing precise technical context rather than vague descriptions. You supply relevant code snippets, architectural diagrams, API documentation, and system dependencies to help the AI understand the broader technical ecosystem. You guide the AI through technical decisions by demonstrating deep understanding of software engineering principles, security considerations, and maintainability requirements.
The difference is stark: "Vibe Coding" might be saying "make me a login system", while Context Engineering provides detailed user stories, security requirements, existing authentication patterns, database schema constraints, and specific integration requirements.
Use these AI tools for building, brainstorming, and most importantly, for learning. Be curious about how they work, question their outputs, and understand their limitations. The real power comes when you combine AI's capabilities with your curiosity-driven understanding of whether you're solving the right problem in the first place.
What's particularly valuable is investing time in exploring how these AI tools think about code, what their limitations are, and where they excel. Ask questions of your AI tools, challenge their suggestions, and understand the "why" behind their outputs. The engineers who ask the best questions of their AI tools will build the best solutions.
The Tool Proliferation and Workflow Evolution
One of the most interesting developments in mid-2025 is the sheer number of AI coding tools available, and they're organising into distinct categories based on how they integrate into development workflows. My advice? Try them all.
Vibe Coding Platforms: These enable non-developers or developers to generate and potentially deploy complete applications. Tools like Bolt.new, Lovable.dev, and v0 fall into this category. You describe what you want, and they generate working applications that can be deployed to production environments.
IDE and CLI Integration Tools: These live within existing developer workflows, augmenting how developers work in their familiar environments. This includes Cursor, GitHub Copilot, Augment Code, Kiro, and tools like Junie. They enhance productivity without disrupting established development practices.
Remote Agent Developers: These operate as autonomous agents working on code in their own environments, potentially interacting as if they're remote developers on the team. They make code changes in the background and submit them for review. Examples include OpenAI Codex, Jules, some variations of GitHub Copilot, and emerging features in tools like Augment and Cursor that are introducing this capability.
Here's what I've discovered: the fundamental shift happens when you move from traditional coding to using any AI tool. Once you make that leap, switching between different agentic coding platforms isn't dramatically different. The workflow changes are profound when you go from "writing code manually" to "directing AI to build solutions", but the transition between different AI coding tools is relatively minor if you're using the agentic features rather than just autocomplete.
The agentic coding experience has become remarkably standardised:
- Describe what you want to build
- The AI generates a working implementation
- You iterate by describing changes or refinements
- The AI updates the code accordingly
Whether you're using Cursor's AI agent, Claude Code, or any of the web-based builders, the mental model is essentially the same. You're orchestrating the development process rather than writing every line yourself.
It's important to note that I generally turn off "auto-complete" features from AI tools. If I want to write some code, I'll do it unassisted. This discussion is more about using the agentic mode of code generation as part of the workflow, not having AI write parts of the code whilst you're typing.
Here's what I'm seeing: people can generate functional applications quickly using just prompts, deploy them to production with source control, backups, and payment processing. The whole lot. It's more than a proof of concept; it's a "real MVP" (Minimum Viable Product) that's both minimal and genuinely viable.
However, several critical limitations remain:
-
Security and scalability challenges: The generated code often lacks robust security measures and doesn't scale well without expert intervention.
-
Feature limitations: Users inevitably hit walls where the AI tools simply can't implement certain features or integrations, leaving them stuck without developer assistance.
-
Data integrity risks: Changes to database schemas or other structural elements can result in data loss that non-technical users might not detect until it's too late.
-
Security vulnerabilities: Systems built without security expertise remain susceptible to breaches and attacks that could have been prevented with proper development practices.
-
Maintenance complexity: As these AI-generated systems grow more complex, maintaining them becomes increasingly difficult without understanding the underlying code and architecture.
The people who will thrive in this environment aren't those who can simply prompt an AI effectively (though that's certainly a valuable skill). The real value comes from professionals who combine technical depth with curious problem-solving. These are the people who understand what's happening beneath the surface, who can spot potential issues before they become problems, and who can step in when the AI tools reach their limits. More importantly, they're the ones who ask the right questions: "Is this actually solving the user's problem?" and "Are we building the right thing?" rather than just "Can we build this thing?"
This approach requires both technical expertise (understanding code quality, security, scalability) and the broader perspective that comes from genuinely caring about solving the right problems for real people. The engineers who succeed will be those who use their curiosity to bridge the gap between what AI can generate and what users actually need.
Closing Thoughts
Technology has constantly been evolving, and our roles as technology professionals have evolved in tandem with it. What's unique about this moment is the pace of change. The skills that made someone an effective developer in 2020 are already shifting in 2025, and they'll continue to transform.
Currently, we're in a period where AI tools are incredibly powerful assistants, but they're not replacements for skilled developers with a deep technical understanding. They're like having a junior developer who can write code very quickly but lacks the experience to foresee edge cases, security implications, or maintainability concerns. However, this phase won't last long, and it's best to jump in and use the tools as they change rather than wait and see where they end up; otherwise, you might miss opportunities.
The most powerful combination isn't "AI instead of developers" but "developers wielding AI effectively." Those who understand both the capabilities and limitations of these tools will deliver solutions far more quickly and effectively than either humans or AI could alone.
The most valuable skills now and in the future will be:
- Curious problem exploration and precise problem definition
- System design and architecture knowledge
- Testing and validation expertise
- The ability to effectively prompt and direct AI tools
- Communication and empathy when working with stakeholders
- The curiosity to question assumptions and validate that you're solving the right problem
- Security and scalability expertise that goes beyond what current AI tools can provide
Keep learning, stay adaptable, and remember that our ultimate value isn't in the code we write but in the problems we solve and the people we help. The tools will continue to evolve, but the need for humans who understand technology deeply won't disappear. It will just transform.
I'd love to hear your thoughts on how you're experiencing these changes in your own work. Drop a comment below or reach out directly.
This post represents my thinking as of July 2025.
Comments
Post a Comment