AI tool selection for development

What this skill is for

This skill prevents tool-mismatch waste. It produces a documented tool choice with rationale for a specific development task, considering workflow fit, data exposure, expected output, and review requirements.

When to use this skill

• You are starting a new task and unsure which AI tool to open first.
• You are evaluating tools for a team and need decision criteria.
• You want to justify why a specific tool fits a specific workflow.
• You are mixing tools and need to define boundaries between them.

Real work situations

Refactor a large Python module

A complex refactor across many files with tests is best handled by a terminal agent such as Claude Code or Codex CLI, because they can run tests iteratively and work editor-agnostically. An IDE agent can do it too, but terminal agents are usually better for long-running, multi-file work.

Daily front-end edits

Small, visual front-end changes are best handled by an IDE agent such as Cursor or GitHub Copilot, because the visual diff and inline completion reduce friction.

First-pass PR review

For a GitHub-centric team, GitHub Copilot code review or CodeRabbit is a natural first pass before human review. For multi-platform Git hosting, CodeRabbit is the broader choice.

Inputs required

• Task category — audit, refactor, edit, test generation, review, or automation.
• Repository access level — local only, public repo, or private repo with sensitive data.
• Desired autonomy — advisory only, assisted editing, or autonomous issue-to-PR.
• Privacy risk tolerance — can code leave the local machine or not?
• Expected output — advice, diff, test, PR, or review comments.
• Validation depth — how much human review is available.

Questions to ask

• Where do I work most of the time — terminal, IDE, or GitHub web?
• Can this code leave my machine, or must it stay local?
• Do I need one answer, one diff, or a full PR?
• How much human review will this output receive?
• Am I already paying for a tool that covers this use case?

Working method

1. Classify the task. Audit, refactor, edit, test, review, or automation.
2. Assess access and privacy. Decide whether code can go to a cloud service.
3. Choose the interface. Terminal, IDE, or web/cloud agent.
4. Match the tool. Map the task to a short list of candidate tools.
5. Evaluate autonomy. Determine how much supervision the tool needs.
6. Define validation. Decide how the output will be checked.
7. Document the choice. Record tool, rationale, and fallback options.

Decision rules

• If the code cannot leave the machine, use local tools such as Repomix, Aider, or local models.
• If the task is a single known file, use an IDE agent or direct editing, not a full-repo agent.
• If the task is a complex multi-file refactor, prefer a terminal agent.
• If the workflow is GitHub-centric, Copilot and CodeRabbit integrate most smoothly.
• If you need model flexibility or local models, prefer Aider.
• If you are adding tools to an agent, use MCP only after defining permission boundaries.
• If validation is weak, choose a tool with smaller blast radius and more human review.

Tool selection matrix

Deliverables

• Tool selection note — tool, rationale, and alternatives considered.
• Risk note — privacy, security, and autonomy risks for the chosen tool.
• Validation plan — how the output will be reviewed and tested.

Templates

Tool selection note

Task: [description]
Chosen tool: [name]
Rationale: [one paragraph]
Alternatives considered: [list]
Privacy/security note: [where code goes, what is exposed]
Autonomy level: [advisory / assisted / autonomous]
Validation plan: [tests, review, checks]

Quality checklist

• The task is classified before the tool is chosen.
• Privacy and access constraints are documented.
• The tool's expected output matches the task outcome.
• A fallback tool is identified.
• Validation and review steps are defined.

Common mistakes

• Defaulting to the newest tool. Consequence: poor fit and wasted learning time.
• Ignoring data residency. Consequence: private code reaches unauthorized cloud infrastructure.
• Over-autonomizing. Consequence: agents make changes that bypass review.
• Choosing by popularity. Consequence: the tool does not match the team's workflow.

Agent instructions

When using this skill, gather the task category, access constraints, autonomy needs, privacy tolerance, expected output, and validation depth before recommending a tool. Do not recommend a tool you cannot justify. Separate facts from marketing claims. Cite official sources where possible. Provide at least one alternative and explain the trade-off.

Related skills

• Repository Context Packing with Repomix
• AI Coding Agent Task Design
• AI-Generated Code Review
• MCP Development Workflow

Related Atlas pages

• AI Coding Agents Landscape
• Repository Context Packaging
• MCP for Development Workflows

Verification status and limitations

This skill is a public working interpretation. Tool features, pricing, and data policies change frequently; verify current details on official vendor sites before making procurement or workflow decisions.