Skip to content
    All posts

    AI

    Which AI Tool for Which Job: Coding, Docs, Diagrams & Design

    A decision guide to the AI tool landscape — what to use for coding, docs, slides, HLD/LLD, diagrams, UI/Figma, and websites, and how to choose.

    By Published 6 min read

    Share

    Sign up for a free account to read this article in full.

    Sign up to unlockAlready enrolled?

    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.
    flowchart TD Q{What's the task?} --> C[Write / change code] Q --> D[Design & diagrams] Q --> W[Words: docs / slides] Q --> U[UI / website] C --> C1[Multi-file / refactor / run tests → Claude Code] C --> C2[Inline autocomplete → Copilot] C --> C3[AI-native editor → Cursor] D --> D1[Diagrams-as-code → Mermaid / PlantUML] W --> W1[Drafts → Claude / ChatGPT, then edit] U --> U1[Prototype → v0 / Lovable / Bolt]

    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.

    Keep reading — it's free

    A decision guide to the AI tool landscape — what to use for coding, docs, slides, HLD/LLD, diagrams, UI/Figma, and websites, and how to choose.

    In the rest of this article

    • Diagrams: sequence, flow, ER
    • Documentation
    • Presentations / slides
    • UI/UX & Figma / screen building
    • Building websites
    • Quick reference

    A free account unlocks the rest of this article, the full prompt library, quiz answer reviews and completion certificates. The newsletter is optional.

    Sign upSign in

    Ask about this article

    Get answers grounded in this post. AI-generated — based on this article, and may be imperfect.

    Was this helpful?
    NewerWhat's New in Modern Java — and How to Build AI With ItOlder Context Engineering: The Real Skill Behind Reliable LLM Apps

    Read next

    Article

    I Passed the Claude Certified Developer – Foundations Exam: Here's What Actually Helped

    A personal account of passing the CCA Developer – Foundations exam on my first attempt — how I prepared, what caught me off guard, and my study plan.

    Article

    AI Code Review at Scale: How We Use Claude to Review Every PR Before Humans See It

    Six months, 4,200 pull requests, and a GitHub Actions workflow that catches real bugs before your team reviews. The architecture, prompt, cost, and lessons.

    Article

    I Passed the Claude Certified Associate – Foundations Exam: Here's What Actually Helped

    A personal account of passing the CCA Associate – Foundations exam — study approach, what caught me off guard, and why it's worth your time.

    Scaled AI Weekly

    Enjoyed this? Get more like it every Monday.

    Real architecture decisions, LLMOps patterns that survive production, and engineering leadership advice — from 12+ years of building at enterprise scale. Free. No spam. Unsubscribe anytime.

    Get new articles by email

    Free. We email a confirmation link first, and you can unsubscribe from any email.

    Join engineers building production AI systems

    Comments

    Back to all posts