20 — AI Development Tools: Editors, Codex, and the APIs Behind Them

The AI tooling that now surrounds coding looked like an ever-growing list of competitors — until I noticed they sit at different points in the same loop. The map that fixed it: these tools split into three shapes — AI-native editors, coding agents, and the raw model APIs that power both — and the choice is about where the AI sits in the loop. [1] An AI-native editor embeds suggestions where I'm already typing. A coding agent takes goals and works through a codebase more autonomously. A raw model API lets me build the AI feature myself. They're not competitors so much as different integration points, and most developers use all three layers in a week.

The framing that finally landed is a spectrum of autonomy. At one end, the AI is a fancy autocomplete — I type, it suggests, I accept or reject, and I stay fully in control. In the middle, the AI is a pair programmer that can answer questions, refactor a function, or draft a feature given a spec, but I'm still driving. At the far end, the AI is an agent that takes a goal ("implement and test this feature"), navigates the codebase, writes code, runs tests, and reports back. The further along that spectrum, the more the AI does and the more carefully I have to review what it produced.

AI-native editors: AI where I'm already typing

Cursor and Windsurf are the leading AI-native code editors — editors built from the ground up around LLM features rather than having AI bolted onto a traditional IDE [2][3]. They provide code generation, intelligent autocompletion, refactoring suggestions, and context-aware chat, all inside a familiar editor environment. The unifying idea is _proximity_: the AI lives where my cursor lives, so the friction of "ask the AI" collapses to a keystroke.

The distinction between Cursor and Windsurf is more about flavor than category. Both are forks of the VS Code editor with deep AI integration; both can read the surrounding codebase for context; both support inline suggestions and multi-file edits. The choice between them is the same kind of choice as between any two editors — workflow fit, the specific features that matter to me, and which one's AI behavior I find least annoying. The roadmap also points at Replit, a browser-based IDE that adds real-time collaboration and AI features, valuable when I want zero local setup or need to share a coding session [4].

Coding agents: goal-driven, with review

Claude Code and Codex represent the next step along the autonomy spectrum — coding agents that take goals and act on them [5][6]. Claude Code is Anthropic's agent for understanding natural-language prompts and translating them into functional code across languages — automating repetitive tasks, generating snippets, creating whole functions or modules from descriptive instructions, and able to navigate a codebase to do it [5]. Codex is OpenAI's model for translating natural language into code, adept at interpreting comments and instructions to produce functional code in Python, JavaScript, and more [6].

The difference between an AI-native editor and a coding agent is the shape of the interaction. The editor's AI is reactive — I'm typing, it suggests. The agent's AI is proactive given a goal — I describe what I want ("refactor this module to use the new API, then run the tests"), and it works through the steps. The tradeoff is exactly the autonomy spectrum: more agency means more done for me, and more careful review required, because the agent made decisions I wouldn't have made. The agents that work best in practice are the ones that show their work — the Thought-Action-Observation trace from the agents post — so I can verify the reasoning, not just the final diff.

The model APIs underneath

Underneath every editor and every agent is a raw model API, and the roadmap's "Development Tools" section threads these together for good reason — the same models that power the tools are available to me directly when I build AI features. Claude's and Gemini's APIs power agents and editors that use those models; OpenAI's APIs (including the image-generation, vision, and Whisper speech APIs covered in the multimodal post) power features that need those capabilities [7][8]. Hugging Face Models is the open-weights registry, giving access to pre-trained models for NLP, vision, and audio that I can run myself or through hosted inference [9].

The practical implication: the same model that suggests code in my editor is the model I'd call from a server. When I build an AI dev tool of my own — a custom code reviewer, a documentation generator, a test-writer — I'm composing the same APIs. The line between "using AI dev tools" and "building AI dev tools" is thinner than it looks, because the underlying capability is the same set of model APIs.

Frameworks for multimodal dev features

For features that integrate multiple AI capabilities — say, a tool that reads a design image, generates code from it, and writes tests — the framework layer from earlier applies here too. LangChain and LlamaIndex support multimodal applications, letting me chain a vision model, a code model, and a test runner into one workflow [10][11]. The development-tools section of the roadmap closes the loop: the frameworks I'd use to build any AI feature are the same ones I'd use to build an AI-assisted dev feature, because the primitive operations — call a model, parse the output, decide the next step — are identical.

How I use this

My own workflow uses all three layers, and the discipline is matching the layer to the task. For line-by-line coding — writing a function, fixing a typo, renaming a symbol — I use an AI-native editor (Cursor or Windsurf), because the inline suggestion is the lowest-friction help and I stay fully in control. For larger tasks — implement a feature from a spec, refactor a module, write a set of tests — I use a coding agent (Claude Code or Codex), giving it a goal and carefully reviewing the trace and the diff, because the agency saves real time but the decisions need verification. For building AI features of my own, I drop to the raw model APIs and the frameworks, composing the same capabilities the tools use into whatever shape my product needs. The unifying habit is to never trust the AI output unverified at any layer — inline suggestions can be subtly wrong, agent diffs can introduce bugs, and my own API-based features need evals just like any other. The autonomy spectrum is real, but review is constant across all of it.

References

[1] Anthropic, "Claude Code Overview," 2025. [Online]. Available: https://code.claude.com/docs/en/overview

[2] Cursor, "Cursor Docs," 2025. [Online]. Available: https://cursor.com/docs

[3] Windsurf, "Getting Started," 2025. [Online]. Available: https://docs.windsurf.com/windsurf/getting-started

[4] Replit, 2024. [Online]. Available: https://replit.com/

[5] Anthropic, "Claude Code in Action," 2025. [Online]. Available: https://anthropic.skilljar.com/claude-code-in-action

[6] OpenAI, "Codex," 2025. [Online]. Available: https://chatgpt.com/codex

[7] Google, "Google Gemini," 2024. [Online]. Available: https://gemini.google.com/

[8] OpenAI, "OpenAI Image Generation," 2024. [Online]. Available: https://platform.openai.com/docs/guides/images

[9] Hugging Face, "Models," 2024. [Online]. Available: https://huggingface.co/models

[10] LangChain, 2024. [Online]. Available: https://www.langchain.com/

[11] LlamaIndex, "Multi-modal," 2024. [Online]. Available: https://docs.llamaindex.ai/en/stable/use_cases/multimodal/