AI agent setup: what devs actually use
Someone opened an Ask HN asking about everyone's AI agent setup, and the thread became what these threads always become: a bunch of devs showing off their workbench. Some people run five agents in parallel. Some use just a terminal and an instructions file. And some gave up and went back to autocomplete. I read it and saw myself in almost every phase. So I decided to share what I learned building my own AI agent setup and what I think really matters.
Why everyone is asking the same thing
A little over a year ago, the question was "which model do you use?". Today the model is almost a detail. The good ones are pretty close to each other. What separates a productive session from a wasted afternoon is what sits around the model:
- the context you give it;
- the tools it can call;
- how much it can do without asking for permission;
- how you check what it did.
Nobody has a ready answer because the ground shifted too fast. Everyone has been building their own hacks. Threads like this are basically a hack swap, and that is great. That is how tools really mature, far from the marketing material.
What an AI agent setup needs
After testing a lot of things, mine comes down to four pieces. None of them is exotic.
1. An agent in the terminal. It reads the repo, runs commands, edits files. I prefer the terminal over an IDE extension because the agent sees what I see: the package.json scripts, the tests, the git status.
2. A project instructions file. This is the item that pays off the most and the one most people ignore. A markdown file at the root explaining how the project works. It does not need to be long:
# Project
- Monorepo with Bun workspaces. Apps in apps/, libs in packages/.
- Run tests: bun test (never npm test).
- Database: PostgreSQL. Migrations in packages/db/migrations, never edit one that was already applied.
- New pages use the PageLayout component.
- Do not build several apps at the same time.
Five lines like these prevent about twenty corrections a week. The agent does not guess that you use Bun. If you do not tell it, it will run npm install and create a package-lock.json nobody asked for.
3. Well-defined permissions. Reads and tests run freely. Commits, pushes, deploys and anything that deletes data ask for confirmation. It feels like bureaucracy until the day the agent decides to "clean up" a folder that was not its own.
4. A fast way to verify. Tests, type-check, lint. If the agent can run these on its own and read the error, it fixes itself. If it can't, you become its human compiler.
Is it worth running several agents in parallel?
This is the part of the thread that gets the most attention. People running three, four, eight agents at once, each on a separate branch or worktree. It sounds like the future.
My take: for most devs, it is not worth it. At least not yet.
The bottleneck was never the agent typing. The bottleneck is you reviewing. An agent produces in ten minutes a diff that takes twenty to review carefully. With four running, you become a full-time PR reviewer, and a tired one. Tired reviewers approve wrong things.
An agent that writes faster than you can review just brings the next bug sooner.
Where parallel works well is on independent tasks that are easy to check. A real example: updating the same import pattern across forty files, or generating tests for pure functions that already exist. The result is binary, it passed or it didn't. In that case, sure, let the pack loose.
For a new feature with architecture decisions, I stick with one agent and watch it closely.
MCP, subagents and the risk of collecting tools
Another common pattern is the setup full of MCP servers: database, GitHub, Slack, browser, task manager, all plugged in. I have done it. I had more tools connected than I used in a week.
The problem is that every tool has a cost:
- it takes up context, because its description goes along in every conversation;
- it confuses the model, which sometimes picks the wrong tool;
- it uses resources, and an idle MCP server in the background eating CPU is more common than it seems.
Today I turn on what the project needs and turn off the rest. Local database and GitHub cover 90% of my day. The browser comes in when I am working on the front end and want the agent to see the screen it just broke.
Subagents follow the same logic. They are useful for broad research, like "find every place that calls this function", because they return only the conclusion and do not fill your context with files. For a small task, delegating costs more than doing it directly. A subagent knows only what you wrote in the request. If the request is bad, the answer comes back wrong with all the confidence in the world.
What changes in your workflow
The most concrete change I felt was not writing less code. It was writing more text. Describing a task well became a real technical skill.
A request like "fix the login" gets you a random diff. Something like this gets you a diff you can review:
Google login fails when the user already has an email account.
Error in apps/web/src/auth/callback.ts, on the upsert line.
Goal: link the Google account to the existing account by email.
Do not touch the email/password flow. Add a test for this case.
Notice it is the same text you would send to a junior colleague. Whoever already wrote good issues has an edge. Whoever wrote "it's broken, take a look" will suffer again, now with a machine.
Other practical changes I adopted:
- Smaller commits. I ask the agent to stop after each step. It makes reverting easier.
- Tests first. When the test exists, the agent has a target. Without a test, it declares victory on its own.
- Reading the whole diff. Always. The agent loves to "take the chance" and refactor something you did not ask for.
And one pocket tip: running an agent means running processes. Type-check, build and tests in a loop heat up the machine and burn CI quota. If your laptop turns into a heater every time you open a session, the problem is probably your setup, not the model.
So what is the best setup?
The most boring one possible. One agent, a well-written instructions file, conservative permissions and tests that run fast. After that, every new piece has to solve a problem you already had, not a problem you imagine you will have.
The HN thread is fun precisely because it shows nobody has reached the definitive setup. Whoever says they have is usually selling a course. I keep tweaking mine with every project, and the best setup I have today is the one that lost the most tools over time.
If you want to see where this workflow runs in practice, take a look at the projects I maintain.
LinkedIn summary
Some devs run eight AI agents in parallel. I ended up with just one. I read an Ask HN about agent setups and saw myself in almost every phase. These days the model matters little. What decides is what you put around it. My setup is pretty boring: one agent in the terminal, a project instructions file, conservative permissions and fast tests. Five lines of markdown save me about twenty corrections a week. Parallel agents look like the future, but typing was never the bottleneck. Review is. An agent that writes faster than you can review just brings the next bug sooner. The best setup I have today is the one that lost the most tools over time. What about your setup, is it growing or shrinking? Tell me in the comments. #AI #AIAgents #SoftwareDevelopment #Productivity #DevTools