Habits That Work in Every Tool
- Give context deliberately. The assistant only knows what is in its window. Point it at the specific files, types and examples that matter instead of hoping it finds them.
- Write the rules once. Every serious tool supports persistent project instructions (naming varies: rules files, custom instructions, memories, context files). Put build commands, conventions and boundaries there. See the template in the agentic workflow article.
- Ask for small, verifiable changes. One behaviour per request, with a test that proves it.
- Review diffs, not chat. The chat explanation can sound right while the diff is wrong. Read the changes, run the tests, and look for invented APIs.
- Commit between steps. Version control is your undo button when an assistant takes a wrong turn across many files.
- Match the mode to the task: inline completion for typing speed, chat for questions, edit mode for scoped multi-file changes, agent mode for whole tasks with tests.
- Do not paste secrets or regulated data into tools your organisation has not approved. Check retention and training policies for the plan you use.
- Verify anything version-specific. Models frequently suggest outdated or non-existent library calls. Check the official docs for the version you run.
How to Choose
| If you mostly... | Consider | Why |
|---|---|---|
| Want inline suggestions in your current editor with minimal change | GitHub Copilot or a JetBrains/Gemini plugin | Works inside the editor you already use |
| Want an AI-first editor with strong multi-file editing | Cursor or Windsurf | Editors built around agent and edit workflows |
| Live in a JetBrains IDE and value its refactoring engine | JetBrains AI Assistant | Uses the IDE\'s code understanding |
| Need very large context for reading big codebases or documents | Models with large context windows, such as Gemini tools | Whole-repository questions without chunking |
| Prefer a terminal-driven agent | CLI agents from several vendors | Scriptable, works with any editor, easier to sandbox |
| Prototype user interfaces from descriptions | v0 and similar UI generators | Fast component scaffolding |
| Work in a regulated environment | Whatever your security team has approved | Data handling and audit matter more than features |
Most professionals end up combining two: an in-editor assistant for flow and an agent for larger tasks. Trial each on one real task from your own backlog for a week rather than judging from demos.
GitHub Copilot
Best at: low-friction completions and chat inside VS Code, JetBrains IDEs and other editors, tightly integrated with GitHub.
- Write the comment, then wait. A precise comment or function signature above the cursor steers completions far better than starting a line cold.
- Use the right chat command for the job: explain, fix, generate tests and similar slash commands save you from retyping the same prompts.
- Pull in real context with workspace and file references so answers reflect your code, not generic examples.
- Set custom instructions once (a repository-level instructions file) to encode language, testing and style conventions.
- Use edit and agent modes for multi-file changes, and accept completions partially (word by word) when the idea is right but the details are not.
Cursor
Best at: an AI-first editor (a fork of VS Code) with strong multi-file editing and an agent.
- Three tools, three jobs: tab completion for rote edits, inline edit for scoped changes, and the agent for tasks that touch several files.
- Feed context with @-references to files, folders, docs and symbols instead of pasting code.
- Encode conventions as project rules so the agent follows your architecture and naming.
- Use checkpoints to roll back an agent run, and review in the diff view before accepting.
Windsurf
Best at: agentic editing flows where the assistant plans, edits and runs commands with you in the loop.
- Think in flows, not one-shot prompts: start with the goal, let it propose a plan, and steer between steps.
- Use memories and a rules file for conventions that should persist across sessions.
- Scope the agent to the directories and files involved to keep it accurate.
- Read the plan and the terminal output, and commit between flows.
Gemini (Code Assist, CLI and AI Studio)
Best at: very large context windows, multimodal input, and tight fit with Google Cloud workflows.
- Exploit the large context window: load a whole module or several documents and ask cross-cutting questions.
- Use the IDE integration for completions and chat, and the command-line tool to script repeatable tasks.
- Ground answers in your documentation or repository to reduce hallucination, and ask for sources.
- Prototype prompts in the browser studio before wiring them into an application, and use screenshots or diagrams as input when text is awkward.
JetBrains AI Assistant
Best at: using the IDE\'s semantic understanding (project model, inspections, refactorings) inside IntelliJ-based IDEs.
- Ask about a selection, so the answer is anchored to the code in front of you.
- Generate commit messages from the diff and use AI inside refactoring and explain-code actions.
- Hand larger tasks to the agent (JetBrains calls theirs Junie) and choose the model that fits the task and your policy.
VS Code AI Extensions
Best at: flexibility. The marketplace has completion, chat and agent extensions, including ones that run local models.
- Know what each extension is for, and avoid stacking multiple completion engines, which fight over the same keystrokes.
- Use local models through an extension that supports them when code cannot leave your machine (see small and on-device models).
- Match the tool to the sensitivity of the code, and give extensions project context through their rules or instruction files.
ChatGPT and Codex
Best at: general conversation about code plus a task-oriented coding agent from OpenAI.
- Use projects to keep standing instructions and files so you stop re-explaining your setup.
- Iterate on code in a canvas view for focused edits.
- Delegate whole tasks to the coding agent with clear acceptance criteria, then review the resulting diff.
- Debug with the full picture: paste the error, the relevant code, versions and what you already tried, and ask for the output format you want.
v0 and UI Generators
Best at: turning a description into a React and CSS component quickly.
- Describe the component, not the vibe: states, props, layout constraints and data shape.
- Iterate in small steps and give design context (tokens, existing components).
- Generate for the stack you ship, then review for accessibility, loading and error states, and extract reusable pieces.
Claude Code and Other Terminal Agents
Terminal agents read your repository, edit files and run commands. They are scriptable, work with any editor and are easier to sandbox. Tips for Claude Code specifically are in Claude Code Power Tips.
Safety Checklist
- Confirm which data the tool sends, how long it is retained, and whether it trains on your code, for your specific plan.
- Keep secrets, customer data and production credentials out of prompts and out of agent-accessible files.
- Run agents with the least privilege that lets them finish the task; use a sandbox for command execution.
- Require tests and human review for every change that reaches production.
- Check generated code for licence and security issues like any third-party contribution.
Keeping Up
Pick tools by workflow fit, not by announcement. Re-evaluate every few months on a real task, keep your rules files portable between tools, and avoid building habits that only work in one product. The skills that transfer are specification, context-setting and review.
Frequently Asked Questions
Which AI coding assistant is best?
There is no single best tool. Choose by workflow: in-editor completion (Copilot), AI-first editors (Cursor, Windsurf), IDE-integrated (JetBrains), very large context (Gemini), or terminal agents. Trial candidates on a real task from your backlog.
Can I use more than one AI coding assistant?
Yes, and many developers do, for example one for inline completion and another agent for larger tasks. Avoid running two completion engines in the same editor, since they conflict.
What should I put in a rules or instructions file?
Build and test commands, coding conventions, boundaries on files or actions the assistant must not touch, and a definition of done. Keep it short and update it whenever the assistant repeats a mistake.
Are AI coding tools safe for proprietary code?
It depends on the tool, plan and your organisation's policy. Check data retention and whether your code is used for training, avoid pasting secrets, and prefer approved tools or local models for sensitive code.
Why does my assistant suggest APIs that do not exist?
Models generate plausible code from patterns and may invent or misremember methods, or use older library versions. Verify against the official documentation for your version, and run the tests.