My experience coding with AI

ChatGPT (Website)

Snippets and functions

My first use of AI in coding was with ChatGPT around 2024 ... perhaps. I honestly don't quite remember the first time I interacted with AI for code. At first it was a gimmick that you wouldn't really put too much expectation on but by the time you realized it's in your workflow it's been a year already and it's all a blur.

What I'm sure of is that in the beginning it was a very simple tool to create quick functions and snippets. The utility to quickly create a hook, component, or even a full page was an amazing time-saver. It was also interesting to test around its ability to know how packages worked, to use as a sort of interactive documentation, although at first the training data was not meant for this so the results were not really ideal.

As the GPT model improved it became more useful for more complex tasks like error summary or even correction. It was very useful to be able to just paste in large error call stacks and have it summarize the problem and even suggest solutions. It was also very useful to have it correct code snippets that were not working as intended.

For all the good that ChatGPT could do, it had one big problem; it was not integrated in the workflow and you had to actively copy and paste the code between interfaces. It required a lot of context switching and it was not very efficient. You also had to sometimes be very precise in your prompts to get anything useful. Which is, I guess, where the new Prompt Engineering "field" came from, which has already changed dramatically or you could even argue is already dead in its traditional sense.

Cursor - Editor (Website)

Fantastic logical capabilities, awful integrations

Released in 2023, Cursor aims to integrate AI directly into the coding workflow, reducing the need for context switching and making it easier to leverage AI assistance within the development environment.

I started using it around 2024-25, for a price of 20$ / Month. It was my first experience with an AI-assisted code editor. It had a separate interface next to the code window to prompt the AI, but it edited the code directly which made development much more efficient. It also had nice auto-complete suggestions, inline suggestions and multi-line edits that made typing the code much faster and easier. It removed a lot of manual labor when writing loops, if blocks, etc.

The chat window was context aware and you could manually add files or lines of code to allow the model to specifically concentrate on those.

This was also the point where I realized the AI-assisted writing was fantastic for refactoring code, as you could start writing the change you wanted and it would just apply it to the rest of the file.

The prompting itself was good but was very limited, as soon as multiple files had to change a lot of errors started to occur and the more you asked the more it hallucinated. It was basically a very good single file tool, but since the context was small you had to really be very explicit in the prompts because its ability to read other files and infer the context was quickly overwhelmed. Forget about asking it to refactor a whole project or even simply to create a page with multiple sub-components that link to an API.

Another big problem I encountered was simply the lack of documentation training, a lot of the code was just invented and assumed, it's like the model was not aware of the types and just created object properties that sounded good but simply did not exist. Which was obvious when reading the docs of the package. This made a fantastic tool for logical blocks but awful for integrations like using axios, tailwind, payment providers, etc.

This also made it extremely frustrating to simply ask it to do package upgrades or to fix errors related to package incompatibilities. As soon as the package.json had to be touched, forget about AI, you had to do it manually. It would hallucinate package names and versions like it just took mushrooms.

Augment Code - VSCode Extension (Website)

Fantastic pair-programmer

This is where Augment shone, I first heard about it from a friend that does compiler development and said that he has not typed code in weeks. Very skeptical at first, I thought there is no way that is true. AI cannot be that precise, especially coming from one that made big mistakes in integration.

But it is true that Augment had a much larger context window, and it was a VSCode extension which meant I could go back to it, which was more regularly updated and maintained. Augment was fantastic at changing multiple files and understood context so much better than Cursor. It really made hands-off coding a possibility for me, although I still preferred to do most of the code by hand.

I started with it in October 2025, for 50$ / Month. Quite the raise, but worth it. Efficient and powerful, it made work easier. The tedious tasks less tedious and the fun tasks still fun.

One of its best features was (and still is, I hope) the next-edit. You could write the code and it would automatically infer what the next change would be, which is absolutely the best for refactoring. It was still single file, but you could manually switch files and it would retain the context from the previous changes and the edits would remain precise. You had to manually accept the change and it worked similar to a git diff, but still made the code changes so much faster. And you could really trust it since the origin of the change was your own writing.

Even so, the model here was beginning to become much better at everything. Not only the improvements of the software itself and how it uses the LLMs made a difference, but also the LLMs themselves were becoming very good at code.

During my time with Augment I was prompted many times to try Claude CLI directly, which everybody said was better, but I was reticent because of the ease of use from the chat integration into VSCode. I really liked the manual coding alongside the next-edits and inline suggestions.

Then one day they decided to raise the price. Not only that but they wanted to put the next-edit feature behind an even higher price tag. Around the same time the Claude Code extension for VSCode launched, so this was my opportunity to switch.

Claude Code - VSCode Extension (Website)

My junior employee

I started with Claude Code in March 2026 and have not looked back since. Back to a price of 20$ / Month, it was a no brainer. I did lose the next-edit feature, but ended up adding it from Copilot Pro for 10$ / Month, which was a good compromise. This allowed me to still be able to manually write code efficiently and not only rely on chatting with Claude.

Claude is genuinely impressive. Especially the latest models like Opus 4.8. It handles large context windows, understands how code pieces interconnect, has good training on documentation and does packages very well. It really is capable of building an entire feature from scratch, with multiple files, components, and API calls. It does like to do things its own way, especially in codebases that are young and fresh, where not many components exist. To really achieve your desired goal you have to guide it in many words or, I found, an easier way is to simply write some basic code manually and let the AI do the rest of it. This way it has an understanding of how you code and how you prefer things done.

It's safe to say that the more complete your project is, the better the AI will do its job. It has more context to extract from and generate new pieces of code. It's also very capable of doing deep searches now to really find instances of certain requirements in parts of the code that are barely used. This is perfect for when you want to make a change, or use a feature that you are not sure if it exists already, you can just ask the model and it will easily search for it in the code and give you back where you can find it.

Since it is now much better at integrations as well, I can now let it go alone at creating functions to use features of packages. It even does sometimes much better than I would, since it has access to information almost instantly, faster than I have ever seen before, that I would need days of reading documentation to know about and understand. One key example is using packages that have bad documentation, which honestly happens way too often. The AI has been trained on so many docs, code and comments that it knows how to do it perfectly fine, whereas I would not be able to because there is simply not a page where it is explained.

I am at a point now where I am the architect of the project and the AI is my junior employee. I can delegate tasks to it and it will do them with precision and efficiency. I can also ask it to review my code and suggest improvements, which is a fantastic way to learn and improve my own coding skills. I would even venture to say that it has senior-level knowledge but since it still has to be guided into a framework that suits the project it cannot simply do everything on its own.

The only things now that I really personally handle is the security and the style. The security because of course you want to make sure there are no exploits available, something that you would be responsible for, since the AI has no responsibilities being just a tool. And the style because sure, the AI is nice at creating working components, but style is something that comes out of your head and that's not yet connected to the framework. You are the master of paddings, rounded borders, colors and font. And for me personally, having started my career in 3D modeling, graphic design and web design, this is a good opportunity to focus on looks, knowing that functionality is there (and of course making sure the structure is kept in check, as an architect of the code).

Conclusion

I do still find that coding manually also helps the AI code itself, as well as it helps me code better and faster and implement things quicker. It really is a pair-programming experience alongside a team-mate. In this way I think I will never be obsolete.

The AI will be a member just as I am now. It will certainly reduce the junior requirements in job postings, but will not eliminate them. And it will enable a single person to handle more workload, meaning there will be an increased opportunity for more projects to develop. Developers will have less work on single projects, but more projects to manage, as architects and high-level engineers.