10 Tips for using multiple AI agents

Hey 👋 Until recently my AI coding setup was the default one: VS Code with GitHub Copilot, same as half the industry. Then the pricing changed, I did the math, and the math lost. The subscription math changed: rather than spending $200/month on a single "God-tool" that limits me when credits run dry, I split that budget into yearly plans for Claude and Cursor, plus a discounted Antigravity tier. Now, I use premium credits to architect the task with the best model, and offload grunt work to free-tier tools like OpenCode. If a tool runs out of tokens, it's just a sign to take a break. I took the migration as an excuse to rethink the whole thing instead of swapping one subscription for another. Today I rnow the microphone only works if i go into powerful control and switch to something and then back to analog stereo duplex. how do i permanently fix the microphone?un four tools: Claude Code and Cursor as primaries, with Antigravity and OpenCode as backups. That sounds excessive until you notice each one earns its slot. After a few months of this setup, these are the ten tips I'd give anyone building something similar. The Copilot exit taught me one thing above all the others: never marry a tool, and that includes its config format. Use AGENTS.md instead of CLAUDE.md. Most agents read it now, and you can symlink specific filenames for tools that insist on them. Keep your rules and conventions in the repo, written once, in a format any tool can consume. When the next pricing change lands, switching should cost you an afternoon, not a week. Beyond the IDE, I treat general models like Claude or Gemini as my non-coding "thinking" layer. They handle planning, deep research, and product marketing drafts, or even reviewing my CV. I also use them for life management tasks that don't belong in a code editor, from checking furniture dimensions for a home office layout to getting specific advice on plant care. An agent that plans, codes, reviews, and pushes will do all four things badly. My setup splits the work into specialized roles: a Project Planner, an Orchestrator, and a Code Pusher. Narrow agents drift less, require less context, and when one misbehaves, you know exactly which specific prompt needs fixing. This modularity ensures that each part of the development lifecycle is handled by a focused expert rather than a generalist struggling with a massive instruction set. I manage this flow with a task-.md file, which acts as the shared brain for the fleet. It contains a clear checklist of steps and uses specific "hooks"—well-defined handoff points where one agent leaves a status update that the next one picks up. This system ensures that even if I switch providers mid-task, the new agent knows exactly what has been completed and what the next objective is without me repeating instructions. My code reviewer is modeled on Gilfoyle from Silicon Valley. The tone is heavy on sarcasm, jokes, and cold, hard criticism that doesn't pull any punches. While it might sound harsh, it makes PR reviews a blessing to read because it keeps me far more attentive than a dry, robotic response would. When the agent is genuinely "mean" about a security flaw or a messy function, I'm much less likely to ignore the feedback. To ensure I don't miss critical advice amidst the snark, I've implemented a "caveat" structure for important outputs. Whenever the agent identifies something that requires immediate manual intervention or carries a high risk, it wraps that content in a specific visual callout. This signals that the information is important enough to warrant my full, focused attention, separating the critical technical warnings from the stylistic sarcasm. Every tool in my rotation has a plan mode, and I use it for anything larger than a single-file change. Correcting a text-based plan costs you one sentence; untangling a bad diff across a monorepo costs you an entire afternoon. Make the agent show its plan, argue with it there, and only allow it to touch your files once you have both agreed on the architectural approach. This step is the single biggest preventative measure against technical debt. While the agent is off processing a heavy task or generating code, don't just sit there. I use that time to take manual notes on edge cases or perform small, surgical fixes in the UI that I don't want the agent to worry about. This parallel processing keeps the momentum going—by the time the agent is done with the "big lift," I've already polished the small details around it, resulting in a much faster total cycle time. This one changed how I onboard new projects. I wrote a dedicated "factory" skill whose only job is to create other skills and agents. You point it at a new repo, and it scaffolds specialized agent definitions formatted for whichever tool you are using that day. Setting up custom agents used to eat an entire evening of manual configuration, but now the entire foundation of a project-specific workflow is laid out in just a few minutes. The factory works by proactively requesting information about my chosen providers and the project's specific coding conventions. Once it understands the stack and the rules, it automatically generates or updates skills as necessary to ensure they are perfectly aligned with the repository's architecture. This automation ensures that every agent I spin up is already "vetted" on the project's specific style guides and library choices before it ever writes its first line of code. Skills compound over time. You write them once and they run hundreds of times, so the quality of the initial writing matters far more than the cost of the tokens used to create them. I always draft my skills using the strongest reasoning model I have access to, even when it is the most expensive one on the market. A perfectly articulated skill is a force multiplier for every cheaper model that executes it later. Paying for premium tokens for a single document that steers a thousand future sessions is the easiest trade in this entire setup. If the "master instruction" is flawless, even smaller, faster models can perform with high reliability. Investing in that initial high-reasoning draft saves you from the frustration of debugging poorly followed instructions in the weeks that follow. Every MCP server, skill, and file you leave enabled eats into your context budget before you have even typed a single word of your prompt. I strictly toggle these per task: git tooling stays on when I am shipping code, but goes off when I am writing documentation. Browser tools are only enabled when something specifically needs live testing. This discipline ensures the model stays focused on the task at hand rather than being distracted by irrelevant background data. Confirming your context budget by actively toggling servers is critical for preventing quality degradation. If your agent starts forgetting basic instructions mid-session or the logic begins to dip for no apparent reason, the culprit is usually context bloat. Clearing out the "noise" by disabling unnecessary tools often restores the agent's reasoning capabilities immediately, keeping the output sharp and accurate. OpenCode runs on a free model in my setup, and that is exactly the point of it. Tasks like PR reviews, basic QA fixes, and documentation passes don't require a frontier reasoning engine; they require patience and a solid checklist. Routing the boring, repetitive work to free tiers preserves your paid credits for the architecture problems that actually deserve the "frontier" price tag. While I typically reserve the free model for "easy wins," it is surprisingly capable of handling complex tasks if the initial "battle plan" is sufficiently descriptive. If the planning agent has already done the heavy lifting of defining the logic, the free model can execute it without any major issues. As long as the roadmap is clear and granular, you don't need to pay for a premium brain to perform the literal typing. Rather than over-engineering a complex decision matrix, I stick to a clear, established routing hierarchy: Claude Code first, Antigravity second, and Cursor third. This simplicity prevents "decision paralysis" and ensures I spend more time coding and less time choosing tools. Claude Code is my default because it is the most robust, while the others serve as specific tactical backups for different scenarios. My ladder is straightforward: Claude Code is the primary for everything. Antigravity steps in when Claude Code is rate-limited or when I need a second opinion on something particularly gnarly. Cursor is reserved for quick, in-editor work where I want to stay close to the files without leaving the IDE. Knowing this hierarchy by heart makes the workflow feel fluid and natural rather than technical and forced. AI agents live in the terminal, so it deserves the same care and configuration as your editor. I focus on maintaining a clean, organized terminal environment that supports parallel agents without it becoming a chaotic mess of overlapping text. A well-managed terminal stops you from losing an agent's output in a sea of tabs and keeps you in control of the multi-agent orchestration. Instead of relying on complex toolsets, I use basic features like Git worktrees to let parallel agents work in the same repo without stomping on each other's changes. By keeping the terminal setup simple and the session management logical, you can track several agents at once with high visibility. This organizational clarity is what allows a single developer to effectively "lead" a fleet of four agents simultaneously without losing focus. The tools will keep changing and the pricing will keep changing faster. The setup that survives is the one where nothing is load-bearing except your own conventions: portable configs, narrow agents, skills you own. Build those once and let the vendors fight over who gets to run them. A few of the skills in this post have grown past my own workflow, and I'm turning them into something you'll be able to use too. More on that soon.