Note on freshness. AI tooling changes faster than almost anything else in this field. This article was first published in June 2025 and last reviewed in July 2026 — the workflow advice holds up well, but model names, pricing, and feature availability move constantly. Always check the vendor documentation linked at the end before relying on a specific version number.
A new partner in the world of programming
Artificial intelligence (AI) is reshaping one industry after another — programming is no exception. AI-powered tools have become a standard part of the modern developer's toolkit. They support us at every stage: writing code, analysing and debugging it, and producing documentation. A few years ago this seemed unattainable; today I find it hard to imagine programming without it.
People with no programming background can now produce working applications (so-called vibe coding) — generating code in a chatbot and pasting it into an AI-integrated editor. As programmers, we shouldn't panic about that. Demand for our skills isn't disappearing; the nature of the work is changing. Instead of writing every line by hand, we spend more time designing architecture, reasoning about systems, and reviewing and correcting code produced by AI agents.
The shift since 2025 has a name worth knowing: agentic coding. Early tools autocompleted the line you were typing. Current tools take a goal, decide which files need to change, make the edits across all of them, run your tests, read the failures, and iterate until the task is done. That is a genuinely different tool, and it needs a different working style — which is most of what this article is about.
Claude: the developer's workhorse
One of the most important players in the AI assistant market is Claude, built by Anthropic. It has a strong reputation for understanding large codebases, following long and detailed instructions, and generating code that actually compiles.
Claude ships as a family of tiers rather than a single model, and that naming has been stable for years even as the underlying models change:
- Haiku — the fastest and cheapest, good for simple, high-volume tasks.
- Sonnet — the balanced default; the tier most people use day to day.
- Opus — the most capable, for hard problems and long autonomous work.
As of July 2026 these are the Claude 5 generation. Do not hardcode a version number from an article — including this one. Check the model overview page instead; it is updated the same day models ship.
Getting started with Claude.ai
Getting started is simple: go to claude.ai and create a free account. The interface is a familiar chat where you describe problems, ask for code, or have complex topics explained in plain language.
File uploads and Artifacts
Claude goes a step beyond a plain chatbot. You can upload files — source code, documentation, a schema dump — and the model answers in the context of what you provided.
What really sets it apart is Artifacts. When Claude generates code, a web page, or a diagram, it opens a separate interactive panel. You can edit the code there, preview the page live, and copy the finished result. It turns the chat window into something much closer to a small development environment.
Working with AI in the terminal
What if you want to move that interaction out of the browser and give the AI access to your whole project? That is what the terminal tools are for.
Claude Code runs a chat loop in your terminal that reads your entire project, creates new files, edits existing ones, and runs commands — no copy-pasting into a browser. Two practical notes if you last tried it in 2025:
- Windows no longer needs WSL. The native installer drops a single binary and puts it on your PATH; Node.js is not required either. PowerShell on Windows 10/11 is enough.
- It isn't only a terminal any more. The same agent is available in desktop apps for macOS and Windows, on the web, and as extensions for VS Code and JetBrains IDEs.
Terminal agents are no longer an Anthropic-only category, either — OpenAI's Codex and Google's Gemini CLI occupy the same space, with the same basic shape: point the agent at a repository and describe the goal.
GitHub Copilot: the most widely used option
GitHub Copilot is probably the best-known AI tool for programmers. It works as an extension for editors including VS Code, Visual Studio, and the JetBrains IDEs, and has grown well past its original autocomplete role.
Inline suggestions and chat
The two features most people use daily:
- Live code suggestions — as you type, Copilot reads the surrounding context and proposes whole lines or blocks. Press Tab to accept. It handles repetitive code, unit tests, and whole functions from a description, and can refactor or translate a selection. Next edit suggestions extend this by predicting where you're likely to edit next, not just what comes after the cursor.
- Chat in the editor — an integrated chat panel where you pick a model, add files to the context, and work through a problem without leaving the IDE.
Agent mode and the cloud agent
The bigger change is agentic. Agent mode lets Copilot plan and execute a multi-step task on its own: it works out which files to touch, edits across all of them, runs terminal commands such as npm install or pytest, reads the output, and iterates until it's finished or stuck.
There is also an asynchronous cloud agent. You assign a GitHub issue to Copilot, and it runs in a sandboxed GitHub Actions environment, pushes commits to a draft pull request, runs your test suite, and requests your review when done. It is the closest thing yet to handing a small task to a junior colleague and coming back later.
Model choice and MCP
Two things worth knowing about how Copilot is put together now:
- It is multi-model. A model picker in the chat panel lets you switch between models from several vendors — OpenAI, Anthropic, Google, and others — for the same conversation. Different models genuinely suit different tasks, so it's worth experimenting rather than leaving the default.
- Extensions are now MCP. GitHub deprecated its proprietary Copilot Extensions in late 2025 and replaced them with the Model Context Protocol. Any MCP server now works as a Copilot integration, and MCP support is generally available in VS Code, JetBrains, Eclipse, and Xcode. If you want to understand what that unlocks, I wrote a separate guide on how MCP servers extend LLM capabilities with real tools.
How to optimise your workflow
Matching the tool to the size of the task matters more than which vendor you pick:
- Chat (claude.ai, ChatGPT, Gemini) — best for starting a project, conceptual work, and debugging something you don't understand yet. Describe the problem precisely and attach a few files for context.
- Editor chat (Copilot, Cursor) — best for individual, well-scoped tasks: a specific question, a contained change. Keep it to one problem at a time.
- Inline chat — good for editing a single function or a few lines. Avoid selecting whole files here; this mode has the least context to work with.
- Agents (Claude Code, Copilot agent mode, Codex) — best for tasks that touch several files or need a test-run-fix loop. These are the ones where the up-front specification matters most: state the goal, the constraints, and what "done" looks like, all at once, rather than dripping it out over five follow-up messages.
One more habit that pays off: keep a project instructions file (CLAUDE.md, .github/copilot-instructions.md, .cursorrules — every tool has its own name for it) describing your conventions, stack, and things the agent should never do. It removes the need to repeat the same context in every session.
Other notable AI tools
Hundreds of AI developer tools have appeared in the last few years. A few worth knowing:
- Cursor — a code editor designed around AI integration from the start. No extra extensions needed.
- Windsurf — another AI-first editor with agentic features built in.
- Amazon Q Developer — an alternative aimed at teams on AWS, with real-time suggestions plus security scanning of your code.
- Aider — an open-source terminal agent that works directly with Git, useful if you prefer something you can inspect and self-host.
Where AI still gets you into trouble
This is the part most tool announcements skip, and it matters more as agents get more autonomous:
- Verification is your job, not the model's. An agent that runs its own tests can still write code that passes tests while doing the wrong thing. Read the diff.
- Confident wrong answers are the failure mode. Hallucinated APIs, plausible-looking library functions that don't exist, and subtly incorrect logic all arrive in the same confident tone as correct output.
- Outdated training data is a real problem for libraries. Models frequently write against last year's API. If you're using a fast-moving framework, give the agent the current documentation rather than trusting its memory — this is exactly what MCP documentation servers are for.
- Never let an agent run commands you wouldn't run yourself. Review shell commands before approving them, keep destructive operations behind confirmation, and don't hand a coding agent credentials it doesn't need.
- Watch scope creep. Left unattended, agents add abstractions, helpers, and error handling you never asked for. If you want a minimal change, say so explicitly.
None of this argues against using these tools. It argues for reading what they produce.
Summary
The hammer didn't replace builders — and AI won't replace programmers. The point is learning to use it well. Being able to write a few lines of code is no longer enough on its own; the market is shifting and we have to shift with it.
Key takeaways:
- Model tiers outlast model versions. "Fast and cheap / balanced / most capable" is the stable shape. Look up the current version rather than trusting any article's number, including this one.
- Agentic coding is the real change. Multi-file edits with a test-run-fix loop is a different tool from autocomplete, and it rewards writing a clear, complete specification up front.
- MCP is now how tools plug in. Copilot dropped its proprietary extension system for it, which makes it a genuinely cross-vendor standard rather than one company's idea.
- Automation and speed. AI handles repetitive work and boilerplate extremely well — that has been true since the beginning and hasn't changed.
- Support and learning. These tools are excellent at debugging, explaining unfamiliar code, and suggesting better practices.
- Working at a higher level of abstraction. You spend your attention on behaviour and design rather than individual lines.
- Verification is fundamental. AI still makes mistakes, and more autonomy means more surface area for them. Your role as reviewer — and as the person accountable for the code that ships — is the part that hasn't been automated.