There's an AI tool for everything now — and the mistake most people make is forcing one tool to do all of it. The chat window you draft emails in is not the best place to refactor a codebase, and the autocomplete that's great in your IDE is the wrong tool for a multi-file migration. The skill is matching the tool to the job. This is the map I actually use, plus the factors to weigh so you can decide for your own context.
First, how to decide (the factors that matter)
Before picking a product, score the task on these — they decide the answer more than brand names do:
- Task shape — is it finishing a line (autocomplete), making a change across files (agent), reasoning about a problem (chat), or producing an artifact (deck/diagram/UI)? Match the tool's interaction model to this.
- Output quality bar — throwaway draft vs. shipped artifact. Higher bar → stronger (often pricier) model + human review.
- Iteration speed — how fast can you see and correct the result? Tight loops beat "perfect in one shot."
- Privacy & data sensitivity — proprietary code, customer data, secrets? Use enterprise/zero-retention tiers or self-hosted; never paste secrets into consumer chat tools.
- Workflow integration — does it live where you already work (IDE, Figma, docs)? Context-switching kills the gains.
- Cost — free tiers are fine for exploration; paid tiers earn their keep on daily, high-value work. Match spend to frequency.
- Lock-in & portability — prefer outputs you own (code, Markdown, diagrams-as-code) over formats trapped in a tool.
Coding
| Tool | Best for | Use when | Avoid when |
|---|---|---|---|
| Claude Code | Agentic, multi-file work in the terminal — refactors, "build this feature," running tests, debugging end-to-end | The task is a change, not a line; you want it to edit many files, run the build, and iterate | You just need a quick snippet (overkill) |
| GitHub Copilot | Inline autocomplete as you type | You're in flow, finishing a known line/function | The task spans files or needs reasoning |
| Cursor | AI-native editor: chat + multi-file edits with a GUI | You want an IDE built around AI and visual diff review | You live in the terminal / CI |
| Chat (Claude/ChatGPT) | Explaining code, planning an approach, one-off snippets | You're thinking, not yet editing | You need it to actually touch the repo |
Always review the diff and run the tests. Generated code is a draft until you've read it.
Architecture: HLD & LLD
Use a strong reasoning model (Claude, ChatGPT) to draft and pressure-test a design: "here are the constraints — propose an architecture, then argue against it and list failure modes." It's excellent at surfacing trade-offs you'd miss.
- Use when: exploring options, sanity-checking a design, generating the first HLD/LLD draft, writing ADRs.
- Avoid / be careful: treating its output as the decision. The model advises; you own the call and are accountable for it. Feed it real constraints, not vibes.
- Capture the result as diagrams-as-code so it lives in the repo and reviews like code.
Diagrams: sequence, flow, ER
Prefer diagrams-as-code — text you can version, diff, and regenerate:
- Mermaid — describe it in text (let an LLM write it), render in Markdown/docs. Great for sequence, flow, ER, state. (Every diagram on this blog is Mermaid.) Use when diagrams live alongside code/docs.
- PlantUML — richer, formal UML when you need it.
- Eraser.io / Excalidraw — visual/collaborative canvas with AI assists. Use when you want a hand-drawn or whiteboard feel.
Why code over drag-and-drop: a PNG rots the moment the system changes; a text diagram stays in sync with the repo and reviews like code. Avoid binary diagrams in long-lived docs.
Documentation
- Drafting & cleanup — Claude / ChatGPT to turn notes into prose, summarise, restructure, or generate READMEs/changelogs. Use when you have the facts and need shape. Avoid publishing unread — models confidently state wrong specifics.
- Knowledge bases — Notion AI for in-place writing/summarising.
- Developer docs — Mintlify and similar for AI-assisted docs sites.
Rule: AI drafts, a human verifies the facts.
Presentations / slides
- Gamma, Beautiful.ai, Tome — generate a full deck from a prompt/outline.
- Copilot in PowerPoint — if you're already in the Microsoft stack.
Use when: you need a fast first draft, structure, and layout. Avoid relying on it for the final narrative, data accuracy, or executive-polish visuals — refine those yourself.
UI/UX & Figma / screen building
- Figma AI / FigJam AI — ideation, first-pass layouts, design chores inside Figma.
- v0 (Vercel), Galileo AI, Uizard — prompt/sketch → UI mockups and, increasingly, real React components.
Use when: going from blank canvas to a credible starting screen fast, or handing devs a component starting point. Avoid treating generated UI as final — accessibility, responsive edge cases, and design-system fit still need a human.
Building websites
- v0, Lovable, Bolt.new — prompt-to-app: generate a working React/Next site you then refine in code.
- Framer AI, Webflow AI — visual builders with AI for marketing/portfolio sites.
The trade-off: these reach a working prototype remarkably fast, but production concerns — SEO, performance, accessibility, real backends, security — still need an engineer. (This site started in a prompt-to-app tool and was then hardened by hand: prerendering, structured data, an API layer, and more.) Use when prototyping or for simple sites; bring an engineer before it's business-critical.
Quick reference
| Task | Reach for |
|---|---|
| Multi-file change, refactor, run tests | Claude Code |
| Inline autocomplete while typing | Copilot |
| AI-native editor flow | Cursor |
| Plan an approach / explain code | Claude / ChatGPT (chat) |
| HLD/LLD reasoning & ADRs | Claude / ChatGPT |
| Sequence / flow / ER diagrams | Mermaid, PlantUML |
| Visual diagram canvas | Eraser, Excalidraw |
| Docs, READMEs, drafts | Claude/ChatGPT, Notion AI, Mintlify |
| Slide decks | Gamma, Beautiful.ai, Tome |
| UI mockups / Figma | Figma AI, v0, Uizard, Galileo |
| Prototype a website | v0, Lovable, Bolt, Framer, Webflow |
Privacy & cost — don't skip these
- Data: never paste secrets, customer data, or proprietary source into consumer tiers. For sensitive work use enterprise/zero-data-retention plans or self-hosted/local models, and check your org's policy.
- Cost: explore on free tiers; pay for the 2–3 tools you use daily on high-value work. A frontier model on the hard 20% of tasks plus cheaper tools for the rest beats one expensive tool for everything.
Principles & anti-patterns
- ✅ Match the tool to the task — autocomplete, agent, chat, and generator are different shapes.
- ✅ Keep designs, diagrams, and content as code/text — versionable, reviewable, portable.
- ✅ Always review AI output — code, docs, and designs are drafts until a human verifies them.
- ✅ Mind data and cost — right tier for sensitivity and frequency.
- ❌ One tool for everything — mediocre across the board.
- ❌ Shipping unread generated code — the fastest path to a subtle production bug.
- ❌ Treating the model's design as the decision — it advises; you decide and are accountable.
Wrap-up
The leverage isn't any single tool — it's a stack you switch between fluently: an agent for code changes, autocomplete for flow, a reasoning model for design, diagrams-as-code for clarity, and prompt-to-app tools for prototypes. Match the shape of the tool to the shape of the work, weigh quality, privacy, and cost, and always keep a human in the loop.