The idea of an intelligent robot that assists a coder in his daily work was, just a short while ago, a dream of futurists and an issue considered as science-fiction. Today – suddenly and unexpectedly – it can be said that it is a reality, which is revolutionizing an entire industry, demanding adaptation, irreversibly changing the way we work.
Developers today have access to advanced AI tools that can help not only to generate the code, but also analyze it, optimize it, test it and ensure the security of projects, all with very high performance and at a low cost.
In this article, we will take a look at a new type of tools for coders and developers, which are AI assistants, or virtual helpers that holistically support the daily work of writing code.
What the AI assistant offers and what it can be used for
AI assistants are sophisticated tools that use language models and machine learning algorithms to significantly improve and speed up the software development process. The most popular of these, such as GitHub Copilot or Tabnine, are trained on very large code bases, so they can recognize and suggest solutions to virtually any range of programming problems. They operate on the principle of “pair programming,” where AI acts as a virtual partner, assisting the coder in real time.
It can be said that a “standard” for such tools is currently emerging, and they are now fully mature: most of them offer basically similar functionalities, and the choice of a particular solution is a matter of individual preference, perhaps project requirements or – to a lesser extent – the price. These tools can integrate directly with code editors (IDEs) such as Visual Studio Code, offering developers an unprecedented, intuitive work environment.
The following is a general overview of the key capabilities that these tools provide, along with brief examples of their use.
Support for multiple programming languages
AI assistants can integrate to work with any programming language in use, but the quality of the response may depend on the code base on which the model was trained. For example, the Copilot tool will potentially work best with JavaScript and Python, as these are the most popular in the GitHub repositories on which the model was trained.
Generating a code snippet from a text description
AI assistants such as GitHub Copilot can generate code snippets based on natural language. A programmer can write a comment or prompt in the chat window with a description of what kind of solution is needed, and the tool will generate the appropriate code. Example: After typing the comment “a function that sorts an array of numbers in ascending order,” the tool will generate the appropriate code in the chosen programming language.
Autocomplete code as you write it
The tool analyzes the context and suggests next lines or whole code fragments, which significantly speeds up the process of writing simple code fragments. Example: When writing document.querySelector(‘, the tool can automatically suggest the selector ending and the next steps in DOM manipulation.
Analysis of code fragments with refactoring capabilities
AI assistants can analyze existing code and suggest refactoring, which helps to achieve more readable and efficient code. Example: The tool can suggest transforming a long function into several smaller, more modular functions.
Analyze code for bugs, performance and security
AI assistants can automatically detect and fix potential bugs, performance issues and security vulnerabilities in code. Example: the tool can identify a vulnerability to an SQL Injection attack and suggest appropriate fixes.
Automatically write tests for designated code snippets
These tools can generate, for example, unit tests based on existing code, which simplifies the testing process and ensures higher software quality. Example: After pointing to a function, AI can generate a set of unit tests covering various scenarios for using that function.
Ability to generate documentation for a designated piece of code.
AI assistants can automatically create documentation of functions, methods, classes, making it easier for other programmers to understand the code. Example: The tool generates a detailed description of a function, its parameters and returned values, based on the function definition itself.
Ability to analyze the entire project and provide contextual answers.
The tools can analyze the entire project, point out related places in the code and answer questions related to the code base. Example: based on the text prompt, AI can find the code piece where some functionality is implemented, clarify or expand the project configuration, etc.
Generate textual explanations of the indicated code fragment
AI assistants can generate explanations for a selected code snippet, which can be useful when you’re deploying to a new project, or for novice programmers. Example: The tool can explain line by line what a selected block of code does.
Generate commands for the terminal based on text prompts
AI can translate natural language commands into corresponding terminal commands, making it easier to work with the command line. Example: Typing the prompt stop all docker containers in the chat window will generate the command docker stop $(docker ps -aq) with the ability to paste it directly into an opened console window.
A chat window with the ability to ask any question
Virtually all such tools offer an interactive chat window where developers can ask questions about code or technology, and AI answers in real time. The questions don’t have to be strictly code-related, we also get answers from theory, documentation, etc. To a large extent, this can remove the need to search the web for answers to these questions – we get them right away in the code editor.
Support for managing project dependencies and configurations
AI assistants can help to manage project dependencies, automatically generate configuration files and manage packages. Example: The tool can automatically generate a package.json file for a Node.js project, containing all the specified and required dependencies.
Integration with version control systems
AI assistants can work with version control systems to help write commit messages and automatically create pull requests. Example: When a feature is completed, the tool can generate suggestions for a commit message and automatically create a pull request with a description of the changes.
Benefits and risks of using AI tools in daily work
The use of AI assistant type tools brings many benefits to developers, significantly improving various aspects of the software development process. However, like any tool, they can have some disadvantages. Below are the most important advantages and potential negatives to consider when implementing a new tool into your daily work.
Advantages and benefits
Acceleration of work.
AI assistants significantly speed up the process of writing code with features such as autocomplete, code generation based on text descriptions and automatic test writing. Programmers can focus on more creative and complex tasks, saving time on routine tasks. Example: Generating a sort function in JavaScript based on a short description saves time writing and testing code from scratch.
Potential increase in code quality
AI assistants help identify bugs, suggest fixes and optimizations, and automatically generate unit tests, leading to higher quality code. Example: The tool can identify potential security vulnerabilities in JavaScript code, such as susceptibility to XSS attacks, and suggest appropriate fixes.
Support for introducing to a new project
AI assistants can generate documentation, explain the operation of code snippets and answer questions in real time, which is particularly valuable, for example, when introducing to a new project, doing code review or for those learning programming.
Facilitate project management
AI can help to manage project dependencies and configurations, automatically generating configuration files or configuration snippets and managing packages. AI assistants can work with version control systems to help write commit messages and automatically create pull requests.
Disadvantages and risks
Potential errors in the generated code
Most of the tools discussed are models trained on a specific code base, but despite the advanced technology, the generated code may contain errors or not be optimal. Programmers should always verify and test the generated / prompted code – these tools are a help, but they are not able (at least yet) to adequately make all decisions and replace humans. Example: A generated function may work correctly in most cases, but not handle all extreme cases, which can lead to errors in the application.
Tool addiction
Relying on AI assistants can lead to dependence on these tools, which can negatively affect programming skills, especially among novice programmers. Case in point: a young programmer may rely on a tool to the point that he neglects to learn basic programming concepts, such as writing unit tests by hand.
Costs of using the tools
Currently, all advanced AI tools come with a fee – on the one hand, these are relatively small prices, but on the other hand, this is another cost that comes on a permanent basis and must be taken into account.
Privacy and security issues
Using AI tools that analyze code can raise privacy and data security concerns, especially for projects with sensitive information. Example: Companies may be concerned that code analyzed by an AI tool could be used or shared in some way without their permission. Most tools offer built-in privacy assurances or additional choices in this regard.
Overview of selected AI assistants for coders
GitHub Copilot
https://github.com/features/copilot
GitHub Copilot is an advanced coding assistant developed by GitHub in cooperation with OpenAI. It uses the GPT-4 language model, and is trained on a huge code base from GitHub’s public repositories, as well as other resources. It is a tool designed to act as a virtual “pair programmer” that works with the programmer in real time.
Copilot integrates with popular code editors, in particular Visual Studio Code. The chat module offers several detailed contexts, including a “workspace” that allows you to ask questions relating to the entire code base, or a “terminal” that generates commands to paste into the console.
Cost of the tool: there are currently 3 different plans offered with monthly billing – individual for $10, for companies for $19 and enterprise with an expanded set of capabilities for $39.
Cursor
Cursor is a standalone IDE, built on top of Visual Studio Code by Anysphere. The editor, in addition to all the functionality of VSCode, offers a built-in, integrated AI assistant that introduces itself as Copilot++, which is by design a competitive and improved version of Copilot from GitHub. However, both (actually all) of the aforementioned tools are developing dynamically, and at the current point in time for the reader, one is not necessarily “better” than the other.
Cursor offers the option of using its own model called “cursor-small,” which is described as “less advanced than GPT-4, but sufficient for simple editing tasks.”
Cursor presents itself as a tool that allows contextual work on the entire code base, but for some time now, GitHub’s tool (and most others) has also offered this possibility.
At the time of this writing, the Cursor editor actually offers several visible improvements over Copilot, including:
- generated suggestions for code changes are shown in the diff view;
- the editor can generate hints in multiple lines of code at once, or generate them in steps in successive parts of the code (tab navigation);
- chat supports the ability to search the web or attach to the context of the api / library documentation from the given url on the web;
- the ability to attach graphics as visual context to queries.
Cost: the editor is currently offered in three plans, which differ mainly in the number of possible queries of a given type to a given model: Hobby (free), Pro ($20/month), Business ($40/month).
Tabnine
Tabnine is an AI assistant that integrates with the code editor of your choice (much like Copilot) and offers essentially a similar set of UI solutions and functionality as other such tools: autocomplete code in the editor and a chat window for interacting with code and asking questions.
At the time of this writing, however, Tabnine offers some capabilities that set it apart from the previously mentioned tools. These include:
- the ability to select the model used for the job from a broad list; the list offers Codestral, Mistral, Claude Sonnet and the recommended Tabnine Protected model in addition to GPT models; next to each model we have a brief description and information about the model’s privacy, security and performance;
- assurance of increased privacy when using Tabnine models: our code is not stored or shared without permission, models are not trained on our code;
- ensuring that the tool learns our style and patterns and adjusts the generated code suggestions accordingly;
- the “onboarding” context in the chat window, which generates an introduction to the contents of the current workspace: a description, a list of the most important files with a brief description, indications about the tools used;
- in the Enterprise plan, the ability to integrate with the company’s entire code base (e.g., through a github, gitlab account) and match answers to the knowledge gained from there.
- the ability to locally install the tool in a completely private environment
Cost: the tool is offered in three versions: free (very limited), Pro for $15 per month (90-day free period) and Enterprise for $39.
Amazon Q Developer
https://aws.amazon.com/q/developer
Formerly Amazon Whisperer, it is a tool integrated as part of the AWS ecosystem, making it easier for developers to create applications in the cloud. The tool is built on the Amazon Bedrock platform, a service within AWS that provides access to advanced language models and generative AI models (such as Amazon Titan for generating images) from a variety of vendors.
The Assistant integrates with IDEs, but is also available in AWS consoles, for example, and offers similar functionality to the previously mentioned tools: code autocomplete, chat, contextual work with code. In particular, the tool can automatically suggest code that uses various AWS services, such as S3 or Lambda.
Noteworthy is the “dev” context, which allows you to perform, for example, a new functionality in a project: for a given prompt with a description, the tool creates a plan, which, after acceptance, is changed into code and split into files. The assistant can also, in this context, for example, automatically migrate the code to a newer version of the language (currently available for Java only).
Cost: the tool is currently offered in a Free version (quantity and functional limits) and a Pro version for $19 per month.
Summary
We are currently in the process of creating some kind of a standard for a new type of AI tools for coders and developers. Most of the virtual assistants offer a similar set of functionality, that is chat, code suggestions generated on the fly in the editor, and contexts for working with code: refactoring, testing, explaining and documenting code, searching the codebase for the prompted issues.
These tools are developing very rapidly, complementing and exchanging functionalities within the market competition. It is difficult to say which one of them is “the best” – the choice in this regard should be made by each individual himself, taking into account the preferred interface, perhaps some specific functionalities that at the moment distinguish the tool favorably for our daily work. The cost of access is also similar, oscillating between $10 and $20 per month.
Discussing a completely new type of tools for coders, it is worth noting at the end that their appearance on the market is a kind of revolution that will fundamentally redefine and transform the entire industry, and in fact it is already happening. AI tools can already clearly make our work faster, more efficient and more enjoyable, especially in simpler web projects, such as websites built on WordPress.
