A few years ago, I used to spend hours writing code.
I would watch a YouTube tutorial, pause it, write the code myself, run it, get an error, search for the solution on Stack Overflow, try again, debug it, and finally make it work.
And when it worked, there was a different kind of satisfaction.
I could look at the screen and think:
"Yeah, I built this."
Today, things are very different.
I can describe what I want, give a prompt, and within seconds, AI can generate a significant part of the code. Sometimes, I barely write the code myself. My role becomes more about understanding what was generated, reviewing it, testing it, fixing it, and making sure it actually makes sense.
And the interesting part?
I have personally seen this change happen in just around 5–6 years.
That's what made me want to write this blog.
I have been curious recently about how much software development and coding have changed during this relatively short period — and, more importantly, what happens next?
I don't have a definite answer to that.
But I have been on this journey from learning programming in college, writing most of my code myself, using Stack Overflow and YouTube, then moving to ChatGPT, GitHub Copilot, and now AI-assisted and agentic development.
So I thought it would be interesting to look back at how things changed from my perspective.
Not as an expert prediction about the future.
Just as a developer who has watched the way we build software change in front of his eyes.
It started with the basics
I remember my college 3rd and 4th years, around 2022 and 2023.
At that time, I was mostly focused on learning the fundamentals.
Programming.
DSA.
Databases.
Networking.
How compilers work.
How things work under the hood.
And, of course, all the other subjects that came with an engineering or computer science curriculum.
For learning, there were so many resources available.
GeeksforGeeks was one of the websites I used regularly. YouTube was another big one. There were tutorials, blogs, documentation, Stack Overflow, and thousands of other resources.
The internet had already made learning much more accessible.
With affordable 4G and easy access to information, if you wanted to learn something, you could simply search for it.
I used to read tutorials, watch videos, pause them, try things myself, and then move forward.
Honestly, that was fun.
But the interesting thing was that we had to do a lot of the work ourselves.
If I wanted to build a project, I would usually find a YouTube tutorial.
I would watch it.
Pause it.
Write the code.
Run it.
Get an error.
Search for the error.
Try a solution.
And then continue.
Sometimes I would spend hours trying to understand why something wasn't working.
And when it finally worked, the feeling was different.
You actually felt that you had built something.
We used the internet, but we still wrote the code
During that period, I would say around 90–95% of the code I wrote was written by me.
The remaining 5–10% might come from places like Stack Overflow, Bootstrap documentation, tutorials, or other online resources.
And there was nothing wrong with that.
In fact, those resources helped us a lot.
I remember database design being one of those things that felt particularly challenging.
Designing a database, thinking about schemas, understanding relationships, and figuring out how everything should connect was not something I could simply ask a tool to do for me.
I had to think about it.
I had to try something.
Then change it.
Then test it.
Then realise that my original approach wasn't good enough.
And that's where I think a lot of learning happened.
We used to think before we wrote code.
We used to think about how we wanted to solve a problem.
Then we wrote the code.
Then we debugged it.
Sometimes, debugging itself took longer than writing the original code.
Looking back, I think that process taught us something important.
It taught us how to think about problems.
Then ChatGPT happened
I graduated in 2023.
Around the same time, ChatGPT had recently become a big thing.
And honestly, I was shocked.
I remember thinking:
"Is this the peak of coding?"
Suddenly, you could ask a system to write code for you.
You could describe a problem.
Get an answer.
Copy the code.
Paste it.
Make a few changes.
And suddenly, something that might have taken hours could take minutes.
At the same time, I was still preparing for placements and interviews.
So I was still being asked coding questions and DSA questions.
The traditional way of evaluating developers was still very much there.
But something had clearly changed.
AI had entered the development world.
And I don't think most of us knew how quickly things were going to move from there.
My first job — React Native
After graduation, I joined Bee Logical, which was my first organization.
I mainly worked on mobile application development using React Native.
This was another important phase for me.
I started working on real projects instead of college projects.
I started understanding how production applications actually work.
I started learning coding patterns, project structure, APIs, integrations, and many other things that you don't fully understand in college.
I also used ChatGPT quite a lot during this time.
But there was still a strong focus on understanding the fundamentals.
My seniors helped me a lot.
Whenever I got stuck, I could ask them why something was designed in a particular way, why a particular approach was used, or how I could improve my implementation.
And this was still before the agentic AI era.
We weren't giving an AI agent a large task and asking it to build an entire feature.
AI was more like an assistant.
I would ask.
It would answer.
I would decide what to do with that answer.
Then I moved into full-stack development
Later, I moved to Rsquaresoft Technologies.
This was another major change in my career.
I started moving from primarily mobile application development into full-stack development.
Because it was an early-stage startup and the team was relatively young, I also got an opportunity to guide other developers.
This changed the way I looked at development.
I was not only thinking about my own code anymore.
I started thinking about the overall system.
How should the architecture look?
How should different services communicate?
How should the database be designed?
How should the frontend and backend work together?
How should the codebase remain maintainable?
And because I was also involved in PR reviews, I started spending a lot of time reading other people's code.
Interestingly, reviewing someone else's code became another way of learning for me.
Sometimes you see an implementation and think:
"I never thought about doing it this way."
Other times you see something and think:
"Why was this approach used?"
Then you investigate.
You learn.
You improve.
At this stage, we still weren't heavily using tools like GitHub Copilot or Cursor.
It was still relatively early.
The majority of the thinking and coding was still being done by developers.
Then the development process started changing
After that, I moved to one of our clients, HBK World.
This was another important phase for me because the environment was much more structured.
By this point, I had become more of a full-stack developer.
I already had experience with React Native for mobile development, React for web development, and Python FastAPI for backend development.
But here, I started taking features from start to end.
Frontend.
Backend.
Database.
Integrations.
Deployment.
Everything.
Again, I learned a lot from the seniors around me.
But this time, there was one major difference.
GitHub Copilot became a big part of our development workflow.
And this is where I started noticing something that genuinely surprised me.
AI was no longer just helping me find an answer.
It was actually writing a significant amount of the code.
If I had to roughly estimate it, the percentage of AI-assisted code had gone very high.
Maybe around 90–95% of the code was generated or heavily assisted by AI, while only around 5–10% was directly written by me.
Think about that for a moment.
A few years earlier, I was writing around 90–95% of the code myself.
Now the situation was almost completely reversed.
Within just a couple of years.
That was the moment when I started thinking more seriously about where software development was heading.
Then came agentic AI and "vibe coding"
Around this time, we also started seeing a much bigger shift towards AI agents and what people commonly call "vibe coding."
The interaction with AI was no longer just:
"Explain this code."
It became:
"Build this feature."
"Fix this issue."
"Create this component."
"Connect this API."
"Refactor this code."
The role of the developer started changing.
We were still responsible for the software.
But we weren't necessarily responsible for manually typing every line of it.
And I think that's a very important distinction.
And then I moved to ZS Associates
After that, I moved to another client, ZS Associates.
Here, AI-assisted development became even more normal for me.
From day one, I could see that AI was becoming part of the development workflow.
Even when starting a project, I started thinking differently.
Instead of manually setting up everything from scratch, why not ask AI to help create the initial structure?
Instead of writing every component manually, why not describe what I need?
Instead of spending a long time debugging a small issue, why not ask AI to help identify the problem?
And today, I actively use AI while writing code.
Sometimes I write the code.
Sometimes AI writes it.
Sometimes I write the initial idea and AI completes it.
Sometimes AI generates something and I completely rewrite it.
The important part is that the workflow has changed.
When I look at the graph, it feels strange
If I look at my own journey, the graph almost looks like it has completely reversed.
During college:
Human-written code → 90–95%
AI assistance → Very little
Then:
ChatGPT → Assistant
Then:
GitHub Copilot → Regular development tool
And today:
AI-assisted development → A very large part of my workflow
Of course, these numbers are only my personal estimates, not a scientific measurement.
But the change is very real.
And I am talking specifically about my experience in full-stack development.
When I talk to friends working in other areas — data science, Salesforce, SAP, support, and other technology fields — I hear similar stories.
AI is becoming part of their workflows too.
In support, for example, I have heard about AI-enabled systems where a customer can explain an issue, the AI understands the problem, asks follow-up questions if required, identifies a possible solution, and helps move the issue towards resolution.
Think about that.
The system isn't just generating code anymore.
It is starting to understand problems and participate in the process of solving them.
But here comes the scary part
Wait.
This is probably the most interesting part of this whole discussion.
Isn't this a little scary?
At the same time that AI is making developers more productive, we are also hearing about layoffs and job cuts across parts of the IT industry.
There are obviously many factors behind those decisions, and I don't think it would be fair to say that every job cut is because of AI.
But AI is definitely part of the conversation.
And it raises an uncomfortable question.
If AI can help one person do the work that previously required several people, what happens to those roles?
People often say:
"The work of 10 people will eventually be done by 1 person using AI."
Honestly, I can see why people think that.
And in some situations, it may already be happening to some extent.
But then another question comes to my mind.
If AI writes the code, who is responsible for understanding whether that code is actually correct?
Who understands the business problem?
Who makes architectural decisions?
Who knows what should be built in the first place?
Who decides whether the AI-generated solution is actually the right solution?
Maybe that is where the role of the developer is heading.
So, what happens next?
Coming back to the original question:
How has development and coding changed over the years, and what happens next?
If I look at my own journey over the last 5–6 years, I can see a clear transition.
From:
Learning → Thinking → Coding → Debugging
to something closer to:
Understanding → Prompting → Reviewing → Testing → Shipping
And that is a massive change.
But I am genuinely curious about what comes next.
Have we reached some kind of saturation point?
Or are we still just getting started?
Today, we have AI coding assistants.
Then came AI agents.
Then came agentic development.
Tomorrow, maybe the entire software development lifecycle will be handled very differently.
Maybe developers will spend much less time writing code and much more time thinking about architecture, business requirements, system design, security, testing, and decision-making.
Or maybe something completely different will emerge.
Something that we aren't even thinking about today.
And honestly, that's the part I find exciting.
And a little scary too.
Because if this much has changed in just 5–6 years, I genuinely cannot imagine what software development will look like another 5–10 years from now.
I don't have the answer
This blog isn't meant to give a prediction about the future.
I don't know what will happen.
I'm simply looking back at what I have personally experienced.
From writing code line by line in college...
To watching YouTube tutorials...
To searching Stack Overflow...
To using ChatGPT...
To using GitHub Copilot...
To working with AI-assisted development and agents.
The journey has changed more quickly than I expected.
And that's why I wanted to write about it.
Maybe five years from now, I'll come back and read this blog and realise how wrong my assumptions were.
Or maybe some of these thoughts will actually make sense.
Who knows?
But one thing I know for sure:
The way we build software today is very different from how I was building it just a few years ago.
And if the last 5–6 years changed this much...
What do you think the next 5–10 years will look like?
I'd genuinely love to hear your thoughts.