A map of agentic coding tools: what is what, and when to use which
Coding agents, spec-driven methods, skill libraries, cloud agents, agent SDKs and MCP: six layers, what each solves and which ones a team needs.
Open almost any comparison of AI coding tools and you will find Cursor, GitHub Spec Kit and LangGraph in the same table, each with a score out of five. It is like rating a car, a driving manual and an engine factory on one scale. All three have to do with driving. None of them competes with the other two.
The confusion costs real time. A team that adopts a spec methodology to fix what one paragraph in a rules file would have fixed gets weeks of Markdown and the same bugs. A team that switches agents because its process is chaotic gets the same chaos in a new editor. The choice gets simple once you separate the layers and compare tools only within one of them.
This article does that separation. It covers six layers: what problem each one solves, how the main tools in it differ, and when you can leave the layer out. At the end come four typical situations and a starting setup that suits most small product teams.
Checked on 18 November 2026. Every tool below was checked against its own documentation on that day. This field moves fast. In the last few months Gemini CLI stopped serving free users, Windsurf was renamed Devin Desktop, Google Jules announced its shutdown, and MCP got a new, incompatible version of its specification. We review this article every quarter. If a fact here no longer holds, the layer it belongs to most likely still does.
Six layers in one table
| Layer | What it does | Examples |
|---|---|---|
| 1. Coding agent | Reads code, runs commands, changes files | Claude Code, Codex, Cursor, GitHub Copilot, OpenCode |
| 2. Spec-driven method | Imposes an order: requirements, plan, tasks, code | Spec Kit, OpenSpec, BMAD-METHOD, Kiro |
| 3. Skill library | Ready-made work procedures the agent loads when a task needs them | superpowers, agent-skills |
| 4. Parallel and background work | Several agents at once, separate copies of the repository, agents in the cloud | subagents, git worktrees, cloud agents |
| 5. Libraries for building agents | For people who write an agent rather than work with one | Claude Agent SDK, OpenAI Agents SDK, LangGraph, Google ADK |
| 6. Connectors | Give the agent access to tasks, documents and other services | MCP and MCP servers |
Every team needs the first layer. Each of the others solves one specific problem, and a team that doesn’t have that problem pays for the layer and gets nothing back.
1. The coding agent
The agent is the program that puts a model to work on your repository. It reads files, runs tests, changes code and commits. Every other layer plugs into it.
How agents differ
Benchmark scores change with every model release. These five differences change much more slowly:
- Where it runs. Some started in the terminal (Claude Code, Codex, OpenCode, Aider). Others live in an editor (Cursor, Copilot in VS Code and JetBrains, Cline), and most can also run in the cloud and return a pull request (layer 4). Today most of the big ones cover all three. What differs is where they started, and that is still where they work best.
- Which models. Claude Code works only with Claude models, also through Amazon Bedrock or Google Vertex. Codex is built around OpenAI’s models. Cursor, Copilot, OpenCode, Cline and Aider let you choose among vendors, and OpenCode, Cline and Aider also run local models.
- Licence. Codex CLI, Cline, Aider and Gemini CLI are open source under Apache 2.0, OpenCode under MIT. Claude Code, Cursor and the Copilot service are proprietary. This matters when you have to know what runs on developers’ machines, or when you want to avoid depending on one vendor.
- How it reads project rules. More on this below, because it is the cheapest thing in the whole map to get right.
- Permissions and isolation. This decides what the agent may do without asking: edit files, run commands, reach the network. Codex treats its sandbox and permission profiles as a core part of the design. Claude Code has permission modes and hooks that can block a command before it runs. Look at this before anything else if the agent will touch production credentials.
A one-line profile of each, by the trait that sets it apart rather than by rank:
- Claude Code (Anthropic): one engine and one configuration in the terminal, the editor, the desktop app, the browser and on the phone, so a session can move between them. It has hooks, skills, subagents and cloud runs.
- Codex (OpenAI): an open-source CLI plus an app, an editor extension and cloud tasks, included in ChatGPT plans. OpenAI also started AGENTS.md.
- Cursor (Anysphere): the editor is the product. It predicts your next edit, offers its own models next to those of other vendors, and shows local and cloud agents in one window.
- GitHub Copilot: built into GitHub. You assign an issue to Copilot and get a pull request back. Since June 2026 usage beyond the seat is billed in credits priced per token.
- OpenCode: open source and not tied to any vendor. It can reuse a ChatGPT or Copilot login you already have, and reads
CLAUDE.mdin folders without anAGENTS.md. - Cline: an open-source VS Code extension and CLI that works with any provider, local models included.
- Devin Desktop (Cognition): the new name for Windsurf, now an editor plus a hub for local and cloud agents.
Two tools older comparisons recommend need a second look. Gemini CLI has served only Google’s paid Code Assist plans and paid API keys since June 2026. Free and Gemini Pro/Ultra users were moved to Antigravity CLI, which is closed source and runs only Gemini models. Aider is still open, works with any model and has a good map of the whole repository, but it has had one release since August 2025.
The rules file: the cheapest layer of all
Every agent reads a file of project rules at the start of a session. AGENTS.md is now the shared format. OpenAI started it, and since December 2025 it has belonged to the Agentic AI Foundation at the Linux Foundation. Codex, Cursor, OpenCode and Copilot read it natively.
Two exceptions are worth knowing. Claude Code reads CLAUDE.md and falls back to AGENTS.md only when there is no CLAUDE.md, or when CLAUDE.md imports it. Gemini CLI reads GEMINI.md and picks up AGENTS.md only when you configure it. In a team with mixed agents, keep the content in AGENTS.md and make CLAUDE.md a single line that imports it.
The file pays off when every rule states the failure it prevents:
## Environment
- Local Postgres listens on 5433, not 5432 (5432 is often taken).
Symptom: tests that passed yesterday fail with "connection refused".
- `src/api/` is generated. Never edit it by hand; run `make generate`.
Symptom: the client compiles, then breaks on the next regeneration.
A rule without a symptom is advice. A rule with a symptom is something the agent, and the next person, can act on when they see that symptom in front of them.
When you can skip this layer: never. Choose the agent that fits where your team already works. If your rules live in AGENTS.md and your skills follow a shared format (layer 3), switching agents later costs a day, not a quarter.
2. Spec-driven methods
An agent writes quickly whatever it was asked to write. That moves the problem to the request: an unclear requirement now turns into a lot of confident code within minutes. Spec-driven methods turn the requirements, the plan and the task list into files in the repository, which a human reads before any code is written.
Birgitta Böckeler of Thoughtworks sorted these tools into three levels:
- spec-first: the spec is written before the code and dropped afterwards.
- spec-anchored: the spec stays and changes together with the code.
- spec-as-source: people edit only the spec and the code is generated from it.
Most tools today are spec-first. That is worth knowing before you expect a spec to still be accurate six months from now.
The main tools
-
GitHub Spec Kit (MIT). Commands lead through
constitution,specify,plan,tasksandimplement.- The constitution holds the project’s principles. Each feature gets its own
spec.md,plan.mdandtasks.md, plus research notes, a data model and contracts. - A newer
convergestep compares the code with the spec and adds anything not yet built totasks.md. - It works with about forty agents. Extensions and presets let an organisation enforce its own standards.
- In an existing codebase it is meant for the next bounded change. Its documentation says plainly that it does not infer specs for existing behaviour.
- The constitution holds the project’s principles. Each feature gets its own
-
OpenSpec (Fission AI, MIT). It is built around changes rather than features. Current specs sit in
openspec/specs/, and each change gets its own folder:- a proposal and a design;
- a task list;
- the requirements it adds, modifies, removes or renames.
When the change is archived, those differences are merged into the current specs. Specs start nearly empty and grow only where the code actually changes. In November 2026 the Thoughtworks Technology Radar moved OpenSpec to “Trial”, for exactly this fit with existing code. Telemetry is on by default and sends only command names and the version.
-
BMAD-METHOD (MIT). A team of agent personas: analyst, product manager, product owner, UX designer, architect and developer. It produces a product brief, a PRD, an architecture document, then epics and stories. It scales down: small changes go straight to the build step. Version 7 is still an alpha that installs as a set of skills, so check which version a guide describes before you follow it.
-
Kiro (AWS). An agent and editor with specs built in. Requirements go in
requirements.mdin EARS notation (“WHEN … THE SYSTEM SHALL …”), followed bydesign.mdandtasks.md. There is a quick mode without approval gates and a separate spec type for bug fixes. It is commercial, with a free tier.
What critics found
Böckeler tried Kiro and Spec Kit in October 2025.
- Kiro turned a small bug into four user stories and sixteen acceptance criteria.
- Spec Kit produced so much Markdown that she wrote she would “rather review code than all these markdown files”. Its agent also ignored notes it had been given and duplicated existing classes.
- The Thoughtworks Radar, in April 2026, kept Spec Kit at “Assess”. It cited reports of instructions growing until they crowded the context, of needless defensive code, and of verbose documents.
Since then the tools have added lighter paths: Kiro’s quick mode, bug-fix specs and Spec Kit’s converge. That answers part of the criticism, not all of it.
When you can skip this layer: a change that takes less than a day, a prototype, or a bug with a clear reproduction. When it is worth it: a feature that crosses several modules, work that several people or agents share, or requirements that must stay traceable after the code ships.
3. Skill libraries
The rules file says what is true about the project. A skill says how to do one kind of work: debug, review, write a test before the code. Without skills the agent takes the shortest path. It writes the code first and then tests that pass against it.
The format
Agent Skills is a folder with a SKILL.md file: a name and a description in the frontmatter, the instructions, and optionally scripts. At the start of a session the agent loads only the names and descriptions. It reads a skill’s full text when a task matches, so thirty installed skills don’t crowd the context.
Anthropic introduced the format in October 2025 and published it as an open standard in December. On 22 October 2026 it handed the format to the same Agentic AI Foundation that holds AGENTS.md and MCP. More than forty agents read it, including Claude Code, Codex, Copilot, Cursor, Gemini CLI, OpenCode and Kiro. A skill written for one agent works in the others.
Two libraries worth knowing
-
superpowers (Jesse Vincent, MIT) enforces one path. Its README calls the workflows “mandatory”, not suggestions. The path runs:
- A conversation about the design, approved in parts.
- A separate worktree.
- A plan made of tasks of two to five minutes, each with exact paths and checks.
- Each task done by a fresh subagent and reviewed twice: first against the spec, then for code quality.
- Tests before code. Code written before its test is deleted.
- A review, then closing the branch.
Around that path sit skills for systematic debugging and for verifying before claiming something is done.
-
agent-skills (Addy Osmani, MIT) is a set of 25 skills along a lifecycle: define, plan, build, verify, review, ship. It has commands such as
/spec,/plan,/build,/test,/reviewand/ship. Every skill ends with the evidence it requires, and includes a table of the excuses an agent typically uses to skip a step.
The difference is in how much they decide for you. superpowers decides the order of work. agent-skills offers a set of procedures and a meta-skill that picks the right one for the task.
Directories such as skills.sh let you install a skill with one command, npx skills add <owner/repo>. A skill is a set of instructions your agent follows with your permissions, sometimes with scripts attached. Read it before installing it, as you would a new dependency, and pin the version.
Where a skill is not enough
A skill is advice the agent may skip under pressure. A hook is a script the agent runs at a fixed moment, such as before a command or after a commit, and it cannot be talked out of it. A hook after every commit that runs the tests and the linter takes one item off the list each person has to remember. Claude Code, Codex, Cursor, Copilot and Gemini CLI all have hooks today.
When you can skip this layer: at the start of a solo project. Add a skill library when you notice yourself typing the same instructions again and again: write the test first, run the tests before you say it works. Add a hook the first time someone ships code they never ran.
4. Parallel and background work
There are three separate mechanisms here, and they are often lumped together:
- Subagents. The main agent hands a subtask, such as searching the code or reviewing a diff, to a subagent with its own context window, and gets a summary back. The main session stays readable, but you pay in tokens. Claude Code, Codex (on by default), Cursor and Copilot in VS Code all have them.
- Worktrees.
git worktreegives each agent its own working copy on its own branch, so two sessions don’t edit the same files. Claude Code (claude --worktree), the Codex app, Cursor and Copilot CLI in VS Code create them for you. - Cloud agents. You start a task from an issue, a browser or a chat. The agent works in a virtual machine and returns a branch or a pull request.
| Cloud agent | How you start it | What you get back | Worth knowing |
|---|---|---|---|
| Claude Code on the web | Browser, phone, desktop app, claude --cloud |
A branch; it can watch a PR and fix failing CI | Shares your plan’s usage limits |
| Claude Code GitHub Actions | @claude in an issue or PR, any GitHub event |
Commits and PRs | Costs Actions minutes plus API tokens |
| Codex cloud | ChatGPT, CLI, Slack | A diff, then a commit or PR when you choose | Each task in its own environment, network allowlist |
| GitHub Copilot coding agent | Assign an issue, chat, CLI, Slack, Jira, Linear | A pull request | One PR per task; sessions on Actions stop after 59 minutes; GitHub-hosted repos only |
| Cursor Cloud Agents | Editor, web, Slack, GitHub, Linear, API | PRs with screenshots and logs | Paid plans only, spend limit required |
| Google Jules | — | — | Shutting down: no new work since 11 November, closes 31 December 2026 |
Every one of these mechanisms makes code appear faster. None of them makes reviewing it faster. A team running five agents and reviewing at the pace of one has a queue, not more output. We wrote about that cost in “The agent doesn’t context-switch. You do.” Cloud agents pay off for well-described, bounded issues, where the review is short because the request was precise.
When you can skip this layer: as long as one session keeps you busy reviewing what it produces.
5. Libraries for building agents
Comparisons mix this layer in most often, and most teams don’t need it. These libraries are for people whose product contains an agent, or who automate something an off-the-shelf agent cannot do. A team that writes its software with agents works one layer up.
- Claude Agent SDK (Python, TypeScript): Anthropic describes it as “Claude Code as a library”, with the same tools, agent loop and context management. It was previously called the Claude Code SDK.
- OpenAI Agents SDK (Python, JavaScript/TypeScript, MIT): agents, handoffs between agents and guardrails. It is the production successor to OpenAI’s Swarm experiment.
- LangGraph (Python, JavaScript, MIT): low-level orchestration for long-running agents that keep state, with resumable execution and steps where a human approves. It works with any model.
- Google ADK (Python, TypeScript, Go, Java, Apache 2.0): Google’s kit for building, testing and deploying agents, also not tied to one model.
Before you build your own agent to automate the team’s work, check what the agents you already have can do. Claude Code runs as a GitHub Action triggered by any repository event. Copilot’s agent starts from an issue. Codex takes tasks from Slack, Cursor from Slack, GitHub and Linear. Writing a custom agent makes sense when the agent is the product, not when it is plumbing.
When you can skip this layer: whenever the agent is not part of what you sell.
6. Connectors: MCP
The agent sees the repository, but the work lives elsewhere: tasks in a tracker, errors in Sentry, designs in Figma, decisions in documents. The Model Context Protocol is the standard way to give the agent tools and data from those places.
- Who governs it. Anthropic launched MCP. In December 2025 it gave it to the Agentic AI Foundation, which Anthropic, Block and OpenAI co-founded under the Linux Foundation.
- The current version. The specification version dated
2026-07-28makes the protocol stateless and drops the session handshake. Servers and clients written for earlier versions need updating. - Remote servers. They work over HTTP with an OAuth 2.1 login, so the agent acts as the signed-in user, with that user’s permissions.
- Official remote servers. GitHub, Atlassian (Jira and Confluence), Linear, Sentry and Figma all run one.
The risk
Every result a tool returns becomes input to the model. Simon Willison calls the dangerous combination the lethal trifecta: access to private data, exposure to content from strangers, and a way to send data out. With all three in one session, a sentence planted in a public issue can tell the agent to send your code somewhere. Mixing MCP servers from different sources assembles exactly this combination.
The practical rules:
- Connect read-only access where you can.
- Don’t put a server that reads untrusted text, such as public issues or e-mail, in the same session as one that can send data out without asking you.
When you can skip this layer: when command-line tools already do the job. An agent can run gh or your tracker’s CLI. MCP pays off for services without a good CLI, and when access has to follow each person’s permissions.
Where the layers overlap
Much of the confusion comes from products that span several layers:
- Kiro is an agent and a spec method in one.
- Copilot is an agent and a cloud agent.
- BMAD version 7 is a method delivered as skills.
- superpowers is a skill library with its own design and planning steps, which makes it a light spec method too.
- Claude Code has subagents, worktrees and cloud runs built in.
So “Kiro or Claude Code?” is two questions. Compare Kiro’s agent with Claude Code. Compare Kiro’s specs with Spec Kit or OpenSpec.
The rule that resolves most overlaps is that exactly one tool leads each step of the work: requirements, plan, task list, implementation, review. When two tools each keep their own plan, the agent follows both or neither, and you find out which only when you read the code.
When to use what
One person, a small project
An agent and an AGENTS.md, nothing else for the first few weeks. Add a skill library when you start repeating instructions, and a hook when you catch yourself committing without running the tests.
A team of 3–10, one product
- People may use different agents. They share the rules and the skills:
AGENTS.mdand the skill library are committed to the repository, so everyone’s agent follows the same procedures. - A hook runs the tests and the linter after every commit.
- A spec method only for features that cross modules or take more than a couple of days. Nothing for the rest.
- A human review of every change, as a required step rather than a habit.
- Two parallel sessions per person to start with. A third only when nothing is waiting for review.
- MCP to the tracker and to GitHub, so the agent takes the task from where it lives.
Software with formal requirements
Here the requirement has to outlive the change, so you need spec-anchored work rather than spec-first. Use Spec Kit or OpenSpec, and carry the requirement’s identifier into the task, the branch, the commit and the test.
Kiro’s EARS notation is close to how formal requirements are already written. Whatever the tool, the agent’s output always passes an independent check by a human or a test written from the requirement. We will cover regulated software in a separate article.
A large existing codebase
Spec Kit’s own documentation says it doesn’t infer specs for existing behaviour, so use it for the next bounded change. OpenSpec was built for this case: you write specs only for what you change, and they grow with the code. The rules file matters more here than anywhere else: environment facts, generated folders and traps, each with its symptom. Subagents for exploring the code keep the main session from filling up with file contents.
A starting setup for a small product team
If a team of three to ten people asked us today what to start with, we would suggest this:
| Layer | Choice | Why |
|---|---|---|
| Agent | Claude Code or Codex in the terminal; an editor agent for those who prefer one | Hooks, skills, subagents and worktrees in one tool |
| Rules | AGENTS.md, with CLAUDE.md importing it |
One source of rules for any agent |
| Method | Spec Kit for larger features | Principles, spec, plan and tasks read before any code; converge checks the code against the spec |
| Skills | agent-skills | Tests first, small steps, review, evidence before “done” |
| Enforcement | A hook after every commit | Tests and lint don’t depend on anyone’s memory |
| Parallel work | Two sessions per person, each in its own worktree; a cloud agent for well-described issues | Review is the limit, not the number of agents |
| Connectors | MCP to the tracker and to GitHub | The agent reads the task where it lives |
| Agent SDK | None | Until an agent becomes part of the product |
Spec Kit and agent-skills overlap in two places, the spec and the plan. Split them like this:
- Spec Kit leads up to
tasks.md. For a feature that went through it, skip the/specand/plansteps of agent-skills. - agent-skills leads from the first task to the merge: test first, small increments, review.
- Small changes skip Spec Kit entirely, and agent-skills alone is enough.
If you prefer superpowers to agent-skills, the overlap with Spec Kit is larger, because superpowers has its own design and planning steps. Pick one of the two for that part of the work.
What we would avoid:
- two spec methods in one repository;
- a full methodology for a two-person prototype;
- skills installed from a directory without reading them;
- counting running agents as progress.
What will still be true at the next review
Names, prices and the agent that is best this month will change by the next quarterly review. Some of that has already changed since we started writing.
The layers will stay, and so will the three formats that hold them together: AGENTS.md for rules, SKILL.md for procedures and MCP for connectors. Since October 2026 all three belong to one foundation, not to one vendor. That makes switching agents cheaper every quarter.
The practical conclusion: put your effort into the files that outlive any tool (rules, skills, specs and hooks), and hold your choice of agent loosely.
Where assign2me fits
assign2me sits in the connector layer. Its MCP server lets an agent read a task, comment on it and close it as the signed-in person, with that person’s permissions. Code links to the task by its key in the branch name or the commit message. Details are on the page for teams coding with AI agents.
Sources
All checked on 18 November 2026.
- Agents: Claude Code, Codex, Cursor, GitHub Copilot coding agent, OpenCode, Cline, Devin Desktop, Aider, the move from Gemini CLI to Antigravity CLI.
- Rules: AGENTS.md, how Claude Code reads AGENTS.md, custom instructions in Copilot.
- Methods: GitHub Spec Kit and its notes on existing projects, OpenSpec, BMAD-METHOD, Kiro specs.
- Critique: B. Böckeler, Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl, martinfowler.com, October 2025; Thoughtworks Technology Radar on Spec Kit and OpenSpec.
- Skills: the Agent Skills specification, Linux Foundation: Agent Skills joins the AAIF, superpowers, agent-skills, skills.sh.
- Parallel work: Claude Code subagents and worktrees, Claude Code on the web, Claude Code GitHub Actions, Codex cloud, Cursor Cloud Agents, the Jules changelog.
- Agent SDKs: Claude Agent SDK, OpenAI Agents SDK, LangGraph, Google ADK.
- MCP: specification versions, authorization, Anthropic: donating MCP to the Agentic AI Foundation, S. Willison, The lethal trifecta, 2025.