Dev Tools

Dev tools can look like an endless list of logos. Every week brings a new editor, framework, assistant or platform, and each one claims to be essential. The good news is that underneath the noise, the categories barely change. Once you know what each category is for, any new tool becomes easy to place: it is a better version of something you already understand.

Think of building software like running a workshop. You need a bench to work at, a way to keep track of versions of what you are making, standard connectors so parts fit together, a way to pack the finished piece for shipping, an assistant who can do some of the work, a place to put the finished product on display, and a way to check that it does not fall apart. Those are our seven categories. Let’s leave the workshop there and go through each one properly.

How dev tools fit together

Before the details, here is the path most code takes. You write it in an editor. You record each meaningful change with version control. Your code talks to other systems through APIs. You package it, often in a container, so it runs the same everywhere. You test it, ideally automatically on every change. Finally, you deploy it to hosting, where users can reach it. AI assistants now help at almost every one of those steps.

The categories are not walled off. Your editor shows Git changes and runs tests. Hosting platforms read your Git repository and build containers. AI tools read your codebase, run your test suite and open pull requests. Knowing the categories helps you understand which tool is doing what when everything is wired together.

Code editors and IDEs

The editor is where you spend most of your working day, so it is worth choosing deliberately. Editors range from lightweight text editors to full integrated development environments (IDEs) that bundle debugging, refactoring and project management.

What they do

At minimum, a code editor gives you syntax highlighting, file navigation and search. Modern editors add code completion based on language analysis, inline error reporting, an integrated terminal, Git integration and a debugger that lets you pause a program and inspect its state line by line. Much of this works through the Language Server Protocol, a standard that lets one language analyzer power features in many different editors.

Examples

Visual Studio Code is a widely used free editor with a large extension ecosystem. JetBrains makes a family of IDEs focused on specific languages, such as IntelliJ IDEA for Java and Kotlin, PyCharm for Python and WebStorm for JavaScript. Vim and Neovim are keyboard-driven editors that run in the terminal and remain popular with developers who like to customize everything. Some newer editors are designed around AI from the start, which we cover below.

How to choose

For a beginner, pick one mainstream editor and learn it well rather than switching often. Learn the shortcuts for search, multi-cursor editing, go to definition and the command palette. The editor matters less than how fluently you use it, and an hour learning shortcuts pays back for years.

Version control

Version control records the history of your project so you can see what changed, undo mistakes and work in parallel with others. Today that almost always means Git, a free, open source, distributed version control system.

What it does

Git stores snapshots of your files called commits. Branches let you work on a feature without disturbing the main line of development, and merging brings the work back together. Because every copy of a repository holds the full history, you can work offline and nothing depends on a single server.

Git and the platforms around it

Git runs on your machine. Hosting platforms such as GitHub, GitLab and Bitbucket store copies of your repositories online and add collaboration tools: pull requests for code review, issue tracking and automation that runs on every push. That automation, called continuous integration (CI), is where tests and builds usually run. Our explainer on what Git is covers commits, branches and the difference between Git and GitHub, with commands you can try.

APIs

An API (application programming interface) is a defined way for one piece of software to request data or actions from another. Almost every modern application is built partly from APIs: payments, maps, email delivery, authentication and AI models are all commonly used this way.

Using APIs

As a developer you meet APIs from two sides. You consume them, sending requests to services built by other people and handling their responses. Tools that help here include curl on the command line, graphical clients for sending and saving requests, and the client libraries that providers publish for popular languages. If you are new to the idea, start with our guide on what an API is, which includes a real request you can send in under a minute.

Building APIs

You also build APIs, exposing your own application’s data and actions to front ends, mobile apps or partners. Here, the tools are web frameworks for your language, documentation formats that describe endpoints in a machine-readable way, and testing tools that check responses. The harder part is not the tooling but the decisions: how to name resources, which status codes to return, how to version and paginate. Our guide to API design walks through those choices.

Containers

A container packages an application together with everything it needs to run: the language runtime, libraries, system tools and configuration. The container runs the same way on a laptop, a test server and production, which removes the classic problem of software that works on one machine and fails on another.

Docker

Docker is the most widely known container tool. You describe an environment in a short text file called a Dockerfile, build it into an image, and run that image as a container. Docker Compose extends this to apps made of several containers, such as a web server and a database started together. Our Docker tutorial for beginners builds and runs a working example step by step.

Orchestration

When you run many containers across many machines, you need something to decide where each container runs, restart failed ones and scale up under load. That is orchestration, and Kubernetes is the dominant open source system for it. Kubernetes and Docker are often presented as rivals, but they work at different layers and are commonly used together. Our comparison of Kubernetes vs Docker explains the relationship and when a project actually needs Kubernetes.

AI coding assistants

AI coding tools use large language models to suggest, write, explain and change code. In a few years they have become standard equipment for many developers, and they now touch nearly every other category on this page.

The three types

In-editor assistants work alongside you as you type, offering completions, chat and inline edits; GitHub Copilot is a well-known example, and some editors, such as Cursor, are built around AI from the start. Agentic tools take a whole task, such as fixing a bug or adding a feature, read the relevant files, make changes across them and run commands like your tests; examples include Claude Code and OpenAI’s Codex. App builders generate complete applications from a description in a browser, often with hosting included.

Using them well

The more autonomy a tool has, the more important your review becomes. Commit your work before asking an AI to make significant changes, read the diff afterward, and run your tests. Our overview of AI coding tools sorts current products by type and lists the questions to ask before choosing one.

The rise of these tools also brought a new term. Building software by describing what you want and accepting the AI’s code without reading it is called vibe coding. It is useful for prototypes and personal tools and risky for anything with real users. Our explainer on the vibe coding meaning covers where the term came from and when the approach is fine.

Hosting and deployment

Hosting is where your code runs so that users can reach it. Deployment is the process of getting it there, ideally automatically and repeatably.

The main types

Shared hosting puts many small sites on one managed server and suits simple websites and blogs. A virtual private server (VPS) gives you your own slice of a machine with full control and full responsibility. Managed WordPress hosting specializes in running WordPress with updates, caching and backups handled for you. Cloud platforms offer building blocks such as virtual machines, databases and container services that scale to very large systems. Static and edge platforms deploy front-end sites straight from a Git repository to a global network.

Deployment pipelines

Modern deployment is usually tied to version control. You push to a branch, a CI pipeline runs tests and builds the app, and if everything passes, the result is deployed. Many platforms also create a temporary preview URL for each pull request so reviewers can see changes before they go live. Our guide to the best web hosting explains each hosting type, names providers in each category and lays out how to choose.

Testing tools

Tests are code that checks your code. They are how you find out that a change broke something before your users do, and they are what makes it safe to refactor, upgrade dependencies or accept changes from an AI assistant.

Kinds of tests

Unit tests check small pieces, such as a single function, in isolation, and they run in milliseconds. Integration tests check that pieces work together, such as your code and a real database. End-to-end tests drive the application the way a user would, often by controlling a real browser. A healthy project has many unit tests, fewer integration tests and a small number of end-to-end tests covering the most important flows.

Examples

Each language has its own common test runners: pytest for Python, Jest and Vitest for JavaScript and TypeScript, JUnit for Java. For browser-based end-to-end tests, Playwright and Cypress are widely used. Linters and type checkers are close cousins of tests: they catch whole classes of mistakes without running the code at all.

Where tests run

You run tests locally while working, but the place they matter most is CI. When every push runs the full test suite automatically, a broken change is flagged within minutes, and nobody has to remember to check. Here is a tiny example in Python with pytest:

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5

Save that in a file named test_math.py, install pytest (the Try it section below shows how), and run pytest in the same folder. One passing test is not much, but it is the habit that counts.

The supporting cast

A few tools do not get a category of their own here but appear everywhere. The terminal is the text interface where you run Git, Docker, test runners and most other tools; time spent getting comfortable there is never wasted. Package managers such as npm for JavaScript and pip for Python install and track the libraries your project depends on. Debuggers, often built into editors, let you stop a running program and inspect it instead of guessing with print statements.

Then there is documentation. The official docs of the tools you use are almost always the most accurate source, more current than tutorials and blog posts. Learning to read them quickly is a skill in itself.

Try it

Let’s set up a minimal working toolkit and touch four categories in one sitting. Install a code editor, Git and Python if you do not have them, then run:

mkdir toolkit-check && cd toolkit-check
git init -b main
python3 -m venv .venv
source .venv/bin/activate
pip install pytest

Create test_math.py with the example from the testing section above, run pytest, and confirm it passes. Then commit it with git add test_math.py and git commit -m "Add first test". Finally, use curl -i https://api.github.com/repos/git/git to make a real API request and read the status code. In a few minutes you have used an editor, version control, a test runner and an API. The virtual environment keeps pytest inside this project; on Windows, create it with py -m venv .venv and activate it with .venv\Scripts\activate.

Common mistakes

Most trouble with dev tools comes from how we pick and use them rather than from the tools themselves. A few patterns show up again and again.

• Switching editors, frameworks or assistants every few weeks instead of learning one well
• Treating Git as a backup button rather than writing clear, small commits
• Committing secrets such as API keys to repositories
• Adopting heavy infrastructure, such as Kubernetes, before having the problem it solves
• Accepting AI-generated changes without reading them or running tests
• Skipping tests entirely because the project is “small”, then discovering it grew
• Learning tools from secondhand tutorials and never opening the official documentation

There is a pleasant irony in developer culture: we can spend a whole afternoon configuring the perfect setup instead of writing the code it was meant to help with. A little of that is healthy. A lot of it is procrastination with syntax highlighting.

Where to go from here

The order you learn these in matters more than which brand you pick. A practical path for a beginner looks like this: get comfortable with one editor and the terminal, learn Git, understand how APIs work, then add testing, containers and deployment. AI assistants can help at every stage, as long as you keep reading what they produce.

Here is every guide in this section, in a sensible reading order:

• What Is Git: commits, branches and Git vs GitHub
• What Is an API: requests, responses and your first API call
• API Design: naming, methods, status codes, versioning and errors
• Docker Tutorial for Beginners: build and run your first container
• Kubernetes vs Docker: what orchestration adds and when you need it
• Best Web Hosting: hosting types and how to choose
• AI Coding Tools: assistants, agents and app builders
• Vibe Coding Meaning Explained: the term, the risks and when it is fine

If you only read one next, start with what Git is. Almost every other tool on this page assumes your code lives in a Git repository.