Does AI make programs faster? In short, yes, but how much faster? My experience: about 10 to 50% faster, but not across the board. Let's look at where AI coding really shines and where it doesn't help so much, or might even be a

hindrance. First of all, what do I mean by AI coding? There are three tools that stand out from the pack when it comes to their ability to help programmers code faster and be more productive. Those are Cursor, which is a fork of VS Code—you like VS Code, except it adds a number of

features, including the ability to just ask it to do something for you and have it go ahead and edit all those files. Compare that to ChatGPT, where you can ask for something, but then you're going to have to copy and paste; and if you want to ask it to modify your existing

code, you're going to have to copy that code from your editor into ChatGPT and then take the results and copy them back, which is fairly tedious. Cursor does that for you. Then there's Windsurf. Number two, Windsurf is a lot like Cursor and it's much newer; it just came out in the

past few weeks, and its focus and claim to fame initially was that it has an agent framework, and that means it can do other things for you, like going through files to determine which files will need to be edited, so you can just ask for a feature,

and it will always try to go through your codebase and see if it can come up with the best answer to which files it needs to edit and how. Number three is Tabnine. Tabnine is an open-source command-line tool, so what's cool about this one is

One, it's open source, and two, it runs on the command line. You don't have to infringe upon developers' editor experiences. Some developers can get pretty religious about their editor. In this case, you use AER; you just use it alongside whatever editor you're already using.

Those are the three tools. Why not GitHub Copilot, which you may have heard of? In my experience, it's just not as good; it's simply worse at the job of helping you code faster, helping your team members move faster, and working on an existing codebase. Maybe it got better recently, but last time I tried it, it was significantly worse than Cursor and Windsurf.

Why not ChatGPT, which you've likely used before? Like I said earlier, ChatGPT involves a lot of copy and paste to get code back and forth from your editor. This can get really tedious and, more importantly, it takes time. What we're trying to do here is move faster and ship features faster, fix bugs faster, build applications faster; so anything that takes time is not ideal. Using ChatGPT requires too much copy and paste,

too much shuffling of text from one place to another, so that's a no-go. And if you want to see more about some of these tools—namely Cursor and Windsurf—you can check out my other video that I created about those specifically, comparing the two and how they operate. Now the tools are out of the way; let's look at where AI really shines.

There are three areas in which I think AI coding is extremely helpful today, and we'll likely only get better. Number one: writing tests. Lots of engineers don't want to write tests, but

Of course, engineers also respect that tests make their job easier. If something is desired but you don't want to implement it manually, automated tests are also really easy to determine if they're working or not. You can use something like a TDD approach to write

some code that doesn't yet work, and you write a test, and then you see if the test fails (and it should fail), and then you make your code work, and then the test should succeed. You can do something like that with AI, where the AI writes the test, and then you can

intentionally break whatever feature you just tested in your code, and the test should fail; then you undo that breakage, and it should succeed. So it's very easy to test whether or not the AI's code is doing what it's supposed to do. The fact

that it's very easy to verify the results of having the AI generate your tests is often something a lot of engineers don't want to do; they get a really good candidate for AI coding to jump in and pick up some of the slack.

The other thing about tests is that the more tests you have, the faster you can generally go, even if you're just coding with humans—even if there's no AI involved. The better tested your code base, the more confidence you have as you make other changes, so you can shift

changes relatively quickly with confidence, knowing that if all your tests are passing, at least those things that were tested aren't going to break. Of course, a production app can have all sorts of breakages, so don't skip QA. Number two, where AI really shines is when you are

Building MVPs or prototypes where you're building code that you're not necessarily intending to ship to users or push to production. This is code where you really just want to get a sense of the app, or maybe even internal tooling where the customers, the users

are people in your own company. So if you want to test out a new feature, you can likely iterate on it really quickly using AI to help build it out and then putting it behind a feature flag or just using an internal build of your application with your internal team and seeing how it

works. A lot of times this will help the design process; being able to actually tangibly use a new feature in an app can really help get a sense of how it's going to work and can inform design decisions down the line. It can also

inform architectural decisions because you may discover ways in which it interacts with the rest of your system that you didn't expect.  None of this is news; it's very useful to build MVPs and prototypes and internal tools. So simply put, AI can help you do that faster and

because these internal tools, these MVPs, these prototypes are not going to be used by your end-user base, at least not initially, it's a lower-stakes situation. So if the AI produces code that has bugs that don't manifest immediately, it's not going to be a huge deal. Number three,

where AI really shines is helping onboard your team members. This, I think, is one of the most highly underrated uses for the current crop of AI technology. No matter how senior or junior you are, when you join a new team you're going to have to understand the

codebase at some point, or at least some part of the codebase. However, not everyone else on the team necessarily has time to pair program with you or sit next to you and answer questions all the time. AI is pretty good at that, at least the current tools like Cursor and Wind

Surf are pretty good at answering questions. They're not ready to code for you, but in this case, you're just asking, "Hey, where does this happen? How's that going on? Where is this form submission handled? How is the entry point to this route generated? How do I build the project?"

AI can be surprisingly good at answering these questions because one thing it does is it'll just search the codebase for you. This is a skill that your team should already have as software engineers, but it can still save a ton to have the AI do it for you. And the AI

also comes up with suggestions and determines what might be useful, and it is right often enough that it can essentially serve as a co-pilot. GitHub Copilot was aptly named. AI makes a great co-pilot as you're exploring and learning about a

codebase. So while this doesn't necessarily increase your bandwidth when it comes to output, it decreases the amount of time team members need to get up to speed on the codebase and to be more productive. So that's where AI tools work pretty well. Currently, there are also

areas in which AI coding doesn't help very much or might even be a hindrance. Number one is where the AI doesn't really know the code. If the AI hasn't seen a lot of the code you want to write in its training data, then it's generally worse.

Add it so if you're writing React code in JavaScript, say it's going to be pretty good at that. Python—it's going to be pretty good at that; it's seen a lot of that code because these languages have been really popular over the past 10 years. So a lot of the

code on GitHub and other source repositories is written in Python and JavaScript. And when it comes to frameworks like React, it is really popular; there's just a ton of code out there in the wild that the AI was trained on, so it knows these libraries in these languages better. However, if

you're writing in a more esoteric language or a more esoteric library, or even a library that feels really mainstream but is pretty new—say something that came out in the last few years—then the AI likely won't be that good at it. There are ways that the tools are trying to

improve this; for instance, Cursor can go and fetch a bunch of the documentation and try to ingest it into the AI. But generally, if the AI hasn't seen a lot of it in its training data, it's going to do worse. As an aside, an odd side effect

of this is that I think a lot of teams, or a lot of people building MVPs at least, are going to stick to Python and JavaScript because AI is really good at them. So these two languages are just going to get more popular over time because AI could help write them better,

so it'll save individual people a lot of time. Strength leads to strength. Number two is related to that first point: if you're building something really novel, then the AI naturally hasn't seen a lot of code that does the thing you're trying to do, and it might not be able to

Help that much. This one is really hard to say though, because there is no one type of novel software. So if you're building something unusual, or something that's not a CRUD web app, then your mileage may vary. And then number three, really broadly speaking, if the software

you're writing has really high stakes, you're not going to get a huge benefit because anything that AI writes might be invalid. You can catch a lot of errors before they show up at runtime, but of course, runtime errors do still exist even in languages that try to

prevent them. So if you're writing high-stakes software, generally be more careful with AI or avoid it completely, because the overhead required to verify the code that AI wrote might not be worth it. If I was going to graph this out, it would look something like this, where the lower

the stakes, the higher the productivity boost you're going to get from AI tools. And as the stakes increase, there's generally a drop in productivity up to a point. This is not meant to be exact, but beyond a point, I think it's actually just going to be a hindrance to

using AI; the AI will be wrong so often that it will actually require more of your time and more of your team's time to verify the code that it wrote and likely rewrite it because the AI was not able to accomplish the desired goal. With all that being said, I expect

all of these downsides to get better over time because the AI models over the past few years have gotten better, and also the tools are getting better at the same time. So even if the AI models have peaked and don't get any better, I think

We're still going to see a lot more productivity in the near future as these tools themselves get better at using the existing models. This already happened once recently when the tools gave the AI models the ability to use things like search to search the code base and

the ability to run commands so that they can, instead of asking you, 'Would you like to run this?', they can just run it themselves, look at the output, and iterate from there. So AI tools can definitely help software engineers go faster, but there are still plenty of software

engineers not using AI tools. I know a number of people who don't use any of these AI tools because either they really like their existing editor or they tried the AI tools early on and thought, 'Well, this is not very good,' which it was not. It's got a lot better, but a

lot of people still haven't tried it again after its improvement. Do you know anyone that codes for a living that isn't using tools like Cursor or GitHub Copilot? I'd be curious because, in my experience, these really do lead to a productivity increase, and whether you're operating on

a team or you're building software for your own business or just for yourself, a productivity boost is great and saves time. Also, if you want to see some of these tools in action, namely Cursor and GitHub Copilot, you can check out my other video that I created on this topic, and if you

found this useful, please subscribe to the channel. See you next time.

Does AI Coding Make Programmers Faster

Ian Sinnott

Introduction to AI coding tools and their speed enhancement

AI can make programming 10-50% faster, but not universally.

Cursor, ChatGPT, Windsurf, and Tabnine are highlighted as prominent AI coding tools.

Cursor is preferred over ChatGPT due to its direct code editing capabilities.

Windsurf's agent framework automatically identifies files needing edits.

Tabnine is an open-source command-line tool compatible with various editors.

GitHub Copilot is deemed less effective than Cursor and Windsurf.

AI is highly beneficial for writing tests, automating a task many engineers avoid.

More tests increase coding speed and confidence in code changes.

AI shines in building MVPs and prototypes, allowing rapid iteration.

AI aids team onboarding by quickly answering questions about the codebase.

AI performs poorly on unfamiliar code or less popular languages/libraries.

AI struggles with novel software development tasks.

High-stakes software development requires caution due to potential AI errors.

Ongoing improvements in AI models and tools promise increased productivity.

Many engineers haven't explored or re-evaluated AI tools since early versions.

Productivity gains from AI tools benefit individuals and teams alike.