The Best AI Tools for Developers in 2026 (That I Actually Use)

Overview

The video presents the creator’s “real” AI tool stack for developers in 2026, organized into seven categories:

1. Agent harnesses
2. Models
3. Editors/IDEs
4. Development tech stack
5. Productivity tools
6. Coding frameworks
7. AI platforms

The overall theme is choosing different AI systems depending on the task type—e.g., quick drafting vs. complex bug-fixing vs. cost/automation/local/offline needs.

---

1) Agent Harnesses (tools that run AI models)

The creator uses three main “agent harness” tools:

Claude Code (daily default)

• Usage: multiple times per day via the desktop app
• Tasks:
  • quick questions
  • document analysis
  • scripting video content
  • small coding projects
• Advantage claimed:
  • includes MCP servers/connectors
  • has a large bank of personal/context data inside the tool for faster, actionable answers
• Plan mentioned: ~$200/month tier

Codex

• Usage: less than Claude Code, but preferred for more complex development
• Strength claimed:
  • better verification/testing coverage
  • leads to higher-quality and more reliable code
• Positioning: not primarily for daily productivity—more for “deep dev” work

Hermes agent (hosted on a VPS)

• Usage: for automated life/finance workflows (not primarily development)
• Tasks:
  • tracks emails
  • extracts invoices/receipts/transactions
  • uploads results to a dashboard
• Tooling notes:
  • they previously used other tools (e.g., “Open claw”)
  • prefer these for being user-friendly and cross-device

---

2) Models (which families for which purposes)

The creator describes multiple model “families” and maps them to task stage and complexity.

Anthropic / Claude family

• Models referenced: Opus 5, Fable 5, Haiku, Sonnet (previously)
• Use cases:
  • starting projects from scratch (“zero to one”)
  • general business/productivity/document work
• Rationale:
  • though described as expensive, they’re said to be fast for early-stage creation

OpenAI family

• Models referenced: GPT 5.6 and other newer named models (e.g., “Soul, Luna, Terra”)
• Use cases: complex development, especially:
  • bug fixing
  • working in larger projects
  • scenarios needing more context
• Claimed strength:
  • better for “one to two” iteration steps (or “1.1”-style refinement)
  • output is said to be better verified than Claude for those stages

Open-source models

• Examples mentioned: Kimi and GLM 5.2
• Use cases:
  • long-running tasks where paid credits would get expensive
  • planning looping/credit-heavy work
• Integration options:
  • can be enabled inside tools like Claude Code
  • or brought into editors like Cursor
• Rationale:
  • if already integrated into a tool, setup costs are minimized

Local models

• Model family: Qwen (example: Qwen 3.6)
• Use cases:
  • fine-tuning a model for a specific task
  • limited/no-internet scenarios (e.g., on a plane)
• Claim:
  • runs up to ~27B parameters on their machines
• Usage frequency: rare, but sufficient for short offline productivity/coding

Additional note

• Minimax is recommended (contextually) for Hermes Agent if budget is limited and you want many tool calls.

---

3) Editors / IDEs

The creator emphasizes choosing editors based on project “seriousness” and safety/scale.

• Cursor (primary general-purpose editor)

  • Usage: serious development projects with large repos (thousands of files)
  • Advantage claimed: AI harness/integration is better than Claude Code/Codex
  • Features:
    • switch between models
    • add own models and local models
  • Rule of thumb: not used for very simple tasks—those go to Claude Code

• PyCharm

  • Usage: Python-heavy work:
    • web development
    • data science
    • ML/AI tasks
  • Emphasis: using a “real IDE” for managing large codebases and fixing bugs faster via proper IDE tooling

• CodeRabbit

  • Usage: automated code reviews

---

4) Development Tech Stack (building apps in 2026)

The creator highlights an AI-assisted stack designed to reduce friction.

Node.js + TypeScript (most web apps)

• Claimed coverage: ~90% of their work
• Reasoning:
  • simpler deployments
  • simpler codebase when AI generates both front/back in a coupled way
  • avoids working across separate front-end/back-end languages

Supabase (backend)

• Key features highlighted:
  • easy integration with AI tools via an AI connector
  • direct access to table schema
  • automatic handling of “features” without manual setup
  • includes:
    • cloud functions
    • triggers
    • indexes
    • role-based access control (RBAC)
    • policies
    • auth/sign-in
• Workflow described:
  • connect Supabase from Claude Code using something like MCP
  • avoids dashboard/manual configuration and API-key friction
• Sponsor note: Supabase is a channel sponsor and is used broadly

Python (secondary, for backend-only bots)

• Example: building Discord bots
• Library mentioned: “Discord Pi” / “discord rewrite” (as referenced)

Deployment choices

• VPS: for dedicated hosting in some cases
• Vercel: for other cases
• Claimed benefit: Supabase + Node.js + Vercel integration makes deployment easier, often handled from the AI editor rather than manual dashboards

---

5) Productivity / AI-adjacent Tools

• WhisperFlow (voice dictation)

  • keyboard shortcut dictation → transcribes into text at the cursor position
  • works inside many tools, including native inside Cursor and other AI environments
  • claimed benefits: faster than typing, high accuracy, free to try

• Zapier MCP and Composio (MCP providers / tool connectors)

  • Purpose: connect many apps (Slack, Google Docs, etc.) into one MCP server
    • usable across Cursor, Claude Code, Codex, etc.
  • Benefits:
    • avoids re-authentication across computers
    • supports terminal/CLI use (claimed)
    • provides thousands of apps/tools
  • Differences noted:
    • Composio: easier to connect but “less control”
    • Zapier MCP: “not on discovery,” which may prevent tool-context bloat

• Obsidian

  • used as a personal wiki/knowledge base
  • connected to Hermes agent for accounting/record understanding

---

6) AI Coding Frameworks (building agents/software, not just prompting)

• LangGraph / LangChain (especially with Python)

  • orchestrating agents
  • context management
  • tool calling, etc.

• Pandas + Matplotlib

  • data science workflows (processing/organizing datasets and analysis)

• Streamlit

  • quick dashboards directly in Python without building full APIs/HTML/JS

• Official OpenAI + Anthropic APIs

  • used for simpler applications where model orchestration/switching is straightforward

---

7) AI Platforms (web-based)

These are positioned as hosted platforms rather than locally installed tools:

• GenSpark

  • for building agents/automations/workflows without hosting on a VPS

• Lovable

  • for quickly generating landing pages
  • typically not used for heavy logic apps
  • sometimes paired with a Supabase backend when logic is needed

• Blitzee (enterprise)

  • Workflow described:
    • ingests the entire codebase
    • takes 3–4 days to understand goals
    • outputs very large code changes (hundreds of thousands of lines)
  • Best for:
    • “super serious” projects
    • major refactoring or updating legacy systems in one go

---

Main Speakers / Sources

• Primary speaker: the single creator/host of the YouTube video (referred to as “I” throughout; no other named co-speakers in subtitles)
• Sources/tools referenced:
  • Anthropic (Claude), OpenAI (GPT), Supabase
  • Cursor, PyCharm, CodeRabbit
  • WhisperFlow, Zapier MCP, Composio, Obsidian
  • LangGraph/LangChain, Streamlit
  • GenSpark, Lovable, Blitzee
  • Qwen/Kimi/GLM/local models, Minimax
  • Hermes agent, Codex