Artificial Intelligence (AI) will change everything in software development. I came to this conclusion at the end of 2023, after over 17 years of traditional programming. It was not easy for me to accept that the times are over when you had to check code line by line during bug fixing, and the nth attempt to deploy a project failed because of a simple error that you had overlooked countless times. Because it was also fun! Or in conversations, only those who understand why one might argue about whether semicolons or single quotes are better could follow along.

A generational shift is taking place, and in ten years, no one will talk about the great projects we implemented without AI. The next generation of developers will rather wonder why projects were executed so inefficiently. The field of prompt engineering will play a central role in the future and may possibly replace the classic title of “Developer.”

In recent months, I have used several tools that feel like a glimpse into the future when using them. In all of them, I wrote prompts in natural language and focused on code generation using AI. I know that there are many other tools out there; however, some of them simply did not convince me in comparison, which is why I won’t even bother recommending them to you.

It is important to note that when you use one of these tools, the output may initially be more quantitative than qualitative. This is because the LLMs need to be trained first before they output exactly what you personally want.

ChatGPT (GPT-4o, GPT-o1 Preview)

For me, code generation using ChatGPT is currently indispensable and the best way to exploit the full potential of AI-assisted programming. The suggested code is now so good, except for a few exceptions, that I even delegate simple tasks directly to ChatGPT. It was also interesting for me that it is now possible to generate initial code for a project and output it as a ZIP file. ChatGPT now also remembers your preferences when you use a specific platform or technology and can adjust the output in the context of these specifications. At OpenAI, this is called “Memory.” You can imagine that the biggest disadvantage when working with ChatGPT is the endless copy-paste processes, which in my opinion are acceptable because the quality is simply excellent.

Try it out: http://chatgpt.com

Cursor

Cursor is what I envision for the future when I implement software projects using AI. It allows you to ask questions and solve problems directly in your editor, with context from your entire codebase. The editor strongly resembles Visual Studio Code, which is because Cursor is an AI-powered VSCode fork. With Cursor, you can directly highlight existing code components and have the AI make changes via a prompt panel, which you can accept or reject section by section. Cursor can view your entire code in the context of your prompts, which is a huge advantage compared to the direct use of ChatGPT. In contrast to ChatGPT and Copilot, Cursor is context-sensitive. In addition to GPT models, other models such as Claude can also be used.

Try it out: https://www.cursor.com/

GitHub Copilot

GitHub Copilot was one of the first tools to enable the use of prompts within an editor. In contrast to Cursor, however, the use of the AI assistant seems more cumbersome and less intuitive. Questions concerning your entire code file structure are answered by GitHub Copilot with the note that it cannot search data in your project or recommends the search function. Here, the lack of context sensitivity compared to Cursor is clearly noticeable. While you can reference the workspace using [@workspace/], this seems less intuitive in my eyes. More on this in the GitHub documentation: Chat participants.
However, within an open file and in the chat panel, Copilot works really well and suggests sensible and valid changes in the code based on your prompts. Interesting are also the slash commands like [@tests/], which can be entered in the chat panel and can, for example, automatically create unit tests.

Try it out: https://github.com/features/copilot

Switching between Tools

In my opinion, switching between different tools is problematic. For example, if an LLM within your ChatGPT account is already well-trained, it seems very tedious to switch to another service or editor, as you basically start from scratch there and have to work with the new tool for a while before achieving a similar quality in code output. Have you had similar experiences in this regard?

Challenges

I believe there will be a transition phase where it will be difficult for non-programmers to find prompt engineers who have extensive programming experience and can apply this experience in AI-assisted programming. Traditional CVs will also lose more importance in the future because AI can offer efficient automations that effectively assess a developer’s hard and soft skills. For this reason, I founded devpilot. With devpilot, we want to provide both developers and companies with an optimal process to facilitate collaboration. On devpilot.dev, you will also find exclusively developers who generate code with AI. You can find more information here: https://devpilot.dev/

The Future

If you have already written code line by line without AI for many years, ask yourself what will really change with AI. In the future, AI will write almost all the code you need for your projects. But of course, there will still be a need for architects. A better comparison is this: similar to pilots whom we trust because strict processes ensure that only those with the necessary knowledge and experience are allowed into the cockpit. This principle also applies to AI in software development: only those with the right skills and understanding can truly use these powerful tools to achieve the best results.