Mel – the agentic terminal
The agentic team for coding.
How to onboard a new developer onto AI coding agents in their first week
November 14, 2026 · 6 min read

- Start with one repo and three small tasks, not a tour of every feature.
- Agree on approvals before day one: what the agent may do alone and what it must ask about.
- Make diff review the rule from the first task.
- Mel – the agentic terminal works on Mac, Windows, Linux and VS Code, and is free with your own API key.
To onboard a new developer onto AI coding agents, give them one real repository, a short list of small tasks, approvals set so the agent asks before it runs commands or edits files, and a habit of reading every diff before they commit. Do it over five days, one step a day, and the new person ends the week shipping real work with the agent instead of watching a demo. This guide gives you the plan, the settings to agree on, and where Mel fits.
Why do new developers struggle with AI coding agents?
Most of the trouble is not the agent. It is everything around it.
A new developer is learning your code, your tests, your branches and your people, all at once. Then they get an AI tool with no guidance. Some trust it too much and commit changes they did not read. Others trust it too little and never use it. Both lose time.
The other problem is setup. If every person picks their own tool, their own model and their own key, the team ends up with five ways of working and nobody can help the new person when something goes wrong.
The fix is a short, shared plan: the same tool, the same rules, and small real tasks.
What should you decide before the new developer starts?
Four things, written down in one short page:
- The tool. One AI coding agent for the team, installed the same way on every machine.
- The approvals. Which commands and edits the agent may run without asking, and which always need a person. A good default for a new hire: the agent asks before every command and every edit.
- The models. Which model the team uses for which kind of task, so the new person does not have to guess.
- The bill. Who pays, and on what account. A new person should not have to put a card in or create a key to get started.
This page takes an hour to write once. Every hire after that reuses it.
What does a good first week look like?
Here is a plan that works for most teams. Keep each day small.
| Day | Goal | What the new developer does | What the team lead checks |
|---|---|---|---|
| Monday | Install and run | Installs the tool, opens the team's repo, asks the agent to explain the folder layout and how to run the tests | The tests run on their machine |
| Tuesday | First small fix | Picks a small bug, lets the agent propose a fix, approves each step, reads the diff | The diff was read before commit |
| Wednesday | A missing test | Asks the agent to write a test for code with none, runs it, fixes what fails | The test fails when the code is broken |
| Thursday | A small feature | Plans a small change with the agent first, then builds it in steps | The plan matched what was built |
| Friday | Review and rules | Reviews a teammate's diff with the agent's help, then suggests one change to the team's approval rules | One rule changed or confirmed |
By Friday the new developer has used the agent on the four kinds of work they will do every week: reading code, fixing, testing and building.
How strict should the approvals be for a new hire?
Start strict, then relax with evidence.
In week one, have the agent ask before it runs any command and before it edits any file. This is slower, but it is how the new person learns what the agent actually does. Every approval is a small lesson in your codebase.
From week two, let the person allow the safe things they approved again and again, such as reading files or running the test suite. Keep anything that deletes, deploys or touches secrets behind a person, always.
In Mel, configurable approvals keep you in control of commands and edits, so a team can start a new hire on the strict setting and loosen it later without changing tools.
Why make diff review the rule from day one?
Because the diff is where mistakes are cheapest to catch.
An agent can write a lot of code quickly. A new developer does not yet know which parts of the codebase are fragile. If reading the diff is a habit from the first task, they catch the wrong file, the deleted line and the test that was "fixed" by weakening it, before any of it reaches a teammate.
A simple rule works: nobody commits a change from an agent until they can explain every line of the diff in one sentence each.
Where does Mel fit?
Mel – the agentic terminal · openmel.dev. A multi-agent, multi-model AI terminal for Mac, Windows, Linux and VS Code. Free with your own API key.
For a first-week plan, the parts that matter:
- One tool on every machine. Mel runs on Mac, Windows and Linux, and there is a VS Code extension for people who live in their editor.
- A team of agents works on files, commands, code and diff review, in the same window as your shell.
- Approvals. Configurable approvals keep you in control of commands and edits, so a new hire can start on the strict setting.
- Models. Mel works with Claude, GPT, Gemini, DeepSeek and Qwen (with a key for each, or on a paid plan), so the team can agree on which model fits which task.
- Price. Free with your own API key. Pro is $20 a month and Max is $200 a month.
- One bill for the team. Mel Business has shared credits and one invoice, at $50 a seat with 2 seats minimum, so a new hire joins the team's plan instead of setting up their own billing.
Mel is English only today.
How do you run this with your next hire?
- Write the one-page setup (tool, approvals, models, bill).
- Pick three small, real tasks from your backlog: a bug, a missing test and a small feature.
- Download Mel on the new person's machine and on yours.
- Follow the five days above, and meet for 15 minutes each afternoon.
- On Friday, change one rule on your page based on what the week showed.
- Track one number for each hire: the days until their first reviewed change is merged. If it drops from one hire to the next, the plan works.
If you want to walk through this plan for your own team with someone who knows the tool, write to hello@openmel.dev and we will set up a short demo.
Frequently asked questions
How long does it take to onboard a developer onto an AI coding agent? About a week for the basics, if they work on real tasks from day one. Expect another few weeks before they know which tasks the agent does well in your codebase.
Should a new developer use their own API key? It is simpler if they do not. When the team shares one account and one bill, the new person can start work on day one. With Mel, that is what Business is for: shared credits and one invoice.
Is it safe to let a new hire's agent run commands? It is much safer when a person approves each one. Set the agent to ask before every command and every edit in week one, and keep deletes, deploys and secrets behind a person after that.
Which model should a new developer use? The one your team already agreed on for that kind of task. Write it on the setup page so nobody has to guess, and review the choice every few months.
Does the new developer have to leave VS Code? No. Mel has a VS Code extension, and the same plan works there and in the terminal.

Lalla is a hands-on tech founder, agentic infrastructure architect and the vision behind Mel.
Follow on LinkedIn