The trend is everywhere: AI has come for dev jobs and can now perform 10x or even 100x faster, according to some out there. This would mean reducing headcount, as a single dev could do the work of 10.
But is this really accurate? There seem to be two main trends right now:
1. Vibe coding with AI
Some companies are focusing heavily on speed and releasing new features without requiring devs to review code anymore. In fact, they are not encouraged to take the time to understand the code produced by LLMs. So the flow is:
- Define the feature/specs
- AI implements it
- AI reviews it and fixes any issues
- AI tests it
- AI creates the PR
- The dev might run some more reviews using AI on the PR, might test it locally, and finally clicks approve and merges
The dev never really looks at the code or tries to understand what AI did.
This workflow can truly boost performance for certain tasks, such as creating well-defined new features or releasing a brand-new product. However, it also has major trade-offs in the long run.
Yes, you might meet a very tight deadline to release this product, but can it really scale and grow in the long run? What happens when there is a production issue and you have no clue what AI wrote? What happens when AI can't seem to fix the production issue you are having, even after you pasted all the context you have, and it keeps failing to fix the issue? You have to dig into the code.
And here is where it bites you: you are not at all familiar with the thousands of lines of slop that were written. And I am not talking about a brand-new project. I am talking about a project that has been vibe coded over months, with new requirements built on top of each other over and over, often with features that might conflict with each other or quick fixes that haven't been addressed because no one is taking care of the health of the codebase. The focus was always on shipping fast and zero maintenance.
You could spend hours or even days trying to figure out how to bring your production system back up. This will only amplify over time. Your initial 10x or 100x boost is now greatly reduced by trying to figure out the system and understand why some logic was written in a way that makes absolutely no sense.
This reminds me of when I first started developing a website 20 years ago using Dreamweaver. I got started quickly, but had a hard time fixing issues when they arose, and looking at the code it produced was a huge pain. Of course, AI is at a different level, but there are similarities with vibe coding.
This could certainly improve over time. I could imagine AI monitoring the health of your whole system, being able to communicate with you about the system and its trade-offs while you create a new feature outside of your IDE or code, and proposing scaling changes, migrations, abstractions, or refactoring as needed. However, this might take some time to get right, as it introduces considerable risks.
2. AI-assisted, responsible coding
Others are following an AI-assisted and responsible coding approach, where you are expected to fully own and understand anything AI writes. This flow is much slower than the one above, initially at least, as you have to spend considerable time reviewing, correcting, or modifying AI-produced code to keep it maintainable and feel comfortable with it.
You are not fine with machine-looking code. You want to produce easy-to-understand code for humans that is maintainable by humans in the long run.
Even with very well-defined specs, when you are working on complex systems, there will always be decisions and trade-offs you have to make. Do I need to refactor this to add this new feature? Do I need to introduce a new pattern that was previously not there for this new spec? Does this need to scale? Does another feature need to be deprecated? Should this feature be abstracted into a microservice? Should I migrate certain data to handle the new spec better?
These kinds of judgment calls can't be made by AI alone. AI follows existing patterns and produces quick outcomes. Yes, for a well-built system, AI can really shine initially. It copies the patterns that exist and can quickly add new features on top of them. However, this is temporary. If you keep doing this without reviewing what AI is adding, even in well-built systems, over time it will start making wrong judgment calls on its own, which will add up over time.
You should certainly automate smaller tasks that you feel confident don't need too much review or design changes. I still view this as responsible coding, for example a flow such as:
- Open Jira task
- From Jira delegate to an agent to:
- Creates MR
- Reviews MR
- Tests MR with close to real data
- Dev picks it up, reviews, test on local, approves and merges
So, how much more productive are we?
The question remains: how much more productive are you with AI? From experience, I would say it depends. For certain tasks, you are certainly much faster, such as boilerplate, setting up certain structures, or starting a new project from scratch. However, we need to be careful when measuring performance.
For example: "A bug is reported, and you are asked to investigate and fix it." You can simply paste in the bug description, and AI might have a fix for you very quickly. You push the changes, and it looks all good. However, you were not aware of why that bug surfaced in the first place or of all the related code and logic that surrounds it.
If you were to dig into the code, let's say for one hour, looking for the bug, you would learn a lot about the system and how it was built. You would make a mental map of the codebase and get familiar with a lot of the logic surrounding it, especially if it is readable and well built. You learn to debug logs, understand monitoring systems, and might learn about an unrelated bug in the process.
Later, in a meeting, someone asks about a certain spec. You immediately know it and are familiar with it, and can answer quickly without having to reach for AI to figure it out. You can very quickly debug issues and connect unrelated issues with what they could probably be caused by because you know the system. You are on top of it. If you have no clue, you have to reach out to AI every time and depend on it. This will slow you down over time.
Additionally, the skill of looking at code as live documentation, especially when it is well built and optimized for humans, is very valuable. You can very quickly understand specs by looking at code. Often, asking AI and reading what it says is slower when trying to understand specs. First, you are not 100% sure that what it is saying is really accurate, and second, you might take longer to really understand all the related logic and specs from the output it gives you compared with actually analyzing the code yourself.
Well-written code that is developed with great DX in mind is often more readable than reading about specs in plain English. This is certainly not true for messy code or low-level code with a lot of complexity. AI can be much more helpful for understanding those kinds of codebases.
It's tricky to measure performance with AI because you are measuring long-term versus short-term performance. In the short term, yes, certainly, you are probably a few times faster using AI. However, in the long term, are you really much faster?
If you are working on big, complex projects and are constantly reaching out to AI to figure out the system over and over again, you don't have a mental map of the codebase and need constant assistance. You might not be much faster than a dev who knows the ins and outs of the system and is not using AI at all.
However, if you do have a strong understanding of the codebase and are able to fix issues or add new features confidently without AI, you can certainly be much faster with AI assistance, as you can quickly identify related issues and review the code it changes because you are familiar with it.
It is a bit of a paradox because the more you start using AI, the more you start losing ownership of the codebase. Reviewing code doesn't create the same sense of ownership as writing code manually. It's much better than not reviewing it at all, but over time, you do start losing ownership of the codebase. Additionally, there is a risk of cognitive deskilling when you only review code and rely heavily on AI.
Personally, I would say the performance boost is somewhere around 2x with AI currently, nowhere near 10x and certainly not 100x. That is with AI-assisted, responsible coding. And even this 2x is questionable depending on what you are working on and whether you are measuring the long term or the short term.
I think many people right now are underestimating how fast devs could code manually. You were not literally typing every character. You often copy-pasted a lot of common patterns, mass-reassigned things with shortcuts, used IDE-assisted refactoring, and used autocomplete. I believe many people are underestimating how smart devs were and how much context you could absorb prior to AI.
Yes, AI is very impressive, but devs could do the same or more without hand-holding. I mean implementing a complex solution with zero bugs, with total comprehension of all affected parts and confidence in your solution. That skill is gradually fading in devs nowadays.
I believe AI certainly does boost performance, and everyone should use it. However, I also believe you should keep owning the code and, once in a while, not rely on AI to perform certain tasks, with the exception of autocomplete. Keeping your cognitive sharpness will later help you get more out of AI-assisted coding in the long run.
This is certainly true for bigger, more complex systems. For smaller, newer projects that just need a quick mockup and release, it's a different story. Do not spend too much time on it if you just need a quick release, vibe coding without properly reviewing the code can be perfectly fine here.
