# Agentic Software Development in Teams: Claude Code, Codex and Cursor

> Teams get value from coding agents when configuration, permissions and review are decided together: versioned project instructions, enforced limits on what the agent may run, and tests plus human review for every agent change. The choice of tool matters less.

Canonical URL: https://www.ruebstudio.de/en/guides/ai-agent-development/agentic-software-development-teams  
Author: Dr.-Ing. Marcus Rüb, CEO  
Published: 2026-10-21

A single developer can install a coding agent in an afternoon. A team of twenty cannot simply do the same thing twenty times. Once several people let agents edit the same codebase, you need shared answers: what the agent knows about the project, what it is allowed to do, and how its output is checked before it reaches the main branch.

## What is agentic software development, and why is it different for teams?

Agentic software development means a language model carries out multi-step work on its own: it reads files, edits code, runs commands and checks the result. For a team, the job shifts from writing code towards describing tasks precisely, setting boundaries and reviewing results – and those boundaries have to be the same for everyone.

Individual developers can rely on personal settings. Teams need three things that did not exist before:

- **Shared context** – project knowledge every agent reads at start-up: build commands, architecture decisions, naming conventions.
- **Shared limits** – which commands may run without asking, which files are off-limits, whether network access is allowed.
- **Shared verification** – how agent changes are reviewed, tested and merged.

The 2025 DORA research on AI-assisted development puts it plainly: [AI's primary role is as an amplifier, magnifying an organisation's existing strengths and weaknesses](https://dora.dev/research/2025/dora-report/). A coding agent makes a sound engineering process faster and makes a weak one more visible.

## How does a coding agent fit into a team workflow?

In a team setting a coding agent has four parts: the tool itself, project instructions stored in the repository, permissions that are technically enforced, and your existing pipeline of pull requests, tests and review. The first two are new. The other two exist already but have to cope with more changes arriving faster.

### Project instructions in the repository

All three tools read Markdown instruction files that live in the repository and are versioned with the code:

- **Claude Code** reads `CLAUDE.md` or `.claude/CLAUDE.md`, which Anthropic describes as [instructions shared with team members via source control](https://code.claude.com/docs/en/memory). Personal additions go into a git-ignored `CLAUDE.local.md`. From version 2.1.277, Claude Code also reads `AGENTS.md` when no `CLAUDE.md` exists.
- **Codex** reads `AGENTS.md` files from the Git root down to the current directory, at most one per directory, and stops adding files once the combined size reaches a default of 32 KiB, according to [OpenAI's documentation](https://learn.chatgpt.com/docs/agent-configuration/agents-md).
- **Cursor** uses project rules stored as `.mdc` files in `.cursor/rules`, also supports `AGENTS.md`, and on Team and Enterprise plans adds dashboard-managed team rules that admins can enforce ([Cursor Docs](https://cursor.com/docs/context/rules)).

The practical consequence: a well-maintained `AGENTS.md` reaches all three tools. Tool-specific files only add what one tool can do that the others cannot.

### What belongs in shared project instructions?

Good project instructions contain only what a new colleague would need on day one and what can be checked: commands, conventions, no-go areas. General advice such as "write clean code" does not help an agent; specific rules with a short reason do.

```markdown
# AGENTS.md

## Commands
- Build: `npm run build`
- Tests: `npm test` (must pass before every commit)
- Lint: `npm run lint`

## Rules
- New API endpoints only under `src/api/v2/`; v1 is frozen.
- Database access only through the repository module in `src/db/`.
- Flag any new dependency in the pull request description.

## Off-limits
- Do not modify `infra/` or `.github/workflows/`.
```

Personal preferences – editor settings, private test URLs – stay out of this file and go into each tool's local, uncommitted files. In Claude Code that is `.claude/settings.local.json`, which overrides the shared `.claude/settings.json` for you alone. Running `/context` in a session shows which instruction files were actually loaded, which helps when the agent seems to ignore a rule.

One detail that often surprises teams: in Claude Code, committed `allow` rules only apply after each person has trusted the project folder, while `deny` and `ask` rules apply immediately. Restrictions arrive reliably; permissions may not.

### Permissions and sandboxing

Instructions are requests, not locks. Anthropic says Claude Code treats `CLAUDE.md` as context rather than enforced configuration; anything that must be blocked regardless of what the model decides belongs in a PreToolUse hook or in permission rules. Claude Code supports `allow`, `ask` and `deny` rules in `.claude/settings.json`, which the team can commit so that [everyone who clones the repository gets the same permissions and hooks](https://code.claude.com/docs/en/settings).

Codex separates two controls: the sandbox mode (`read-only`, `workspace-write`, `danger-full-access`) and the approval policy (`on-request`, `never`). In `workspace-write`, OpenAI says the agent [can read files, edit within the workspace, and run routine local commands inside that boundary](https://learn.chatgpt.com/docs/sandboxing). For exceptions, OpenAI recommends rules for specific command prefixes rather than broadly widening access.

### Verification

The agent does not replace the pull request. Its changes travel the same path as human code: branch, automated tests, review, merge. What changes is volume, which the section on risks addresses.

## Which tools and working styles are available?

The three common tools differ less in model quality than in where they run. Claude Code and Codex are mainly terminal agents that work inside the repository (Claude Code also ships extensions for VS Code and JetBrains); Cursor is an editor with an agent built in. What matters is where the team works and how centrally rules can be set.

**Terminal agent in the repository (Claude Code, Codex).** The agent works in the project directory, runs builds and tests, and Claude Code can also run non-interactively for scripted tasks. This suits teams comfortable on the command line with plenty of repetitive work such as dependency upgrades, migrations or adding missing tests.

**Agent inside the editor (Cursor).** The agent sits where developers already read and change code. That lowers the entry barrier for teams who rarely use a terminal, at the cost of tying everyone to one editor.

**Mixed use.** Many teams end up with more than one tool. That works when project instructions are kept tool-neutral in `AGENTS.md` and every change follows the same review path. A detailed comparison of the three tools – permission models, integration, operations – will follow as a separate guide in this topic area.

**Spec first.** Whatever the tool, a useful pattern is to have the agent write a plan or specification that a human approves before any code is written. That moves the most important check to the point where changes are still cheap.

## What does a team need in place first?

The key prerequisite is not a tool but a repository in which an agent can check its own work: a reproducible build, automated tests with meaningful coverage, a linter, and a pull-request process with branch protection. Without these, the only check is a human reviewer – who quickly becomes the bottleneck.

**Technical:**

- Build and tests start with a single command, locally and in CI.
- Branch protection on the main branch, enforced by your Git server, so no agent writes there directly.
- Secrets such as `.env` files and keys kept out of the repository or blocked by a `deny` rule.
- A development environment where the agent cannot reach anything productive: no production credentials on developer machines, separate test databases.

**Organisational:**

- One named owner for the shared configuration (instructions and permissions), with changes reviewed like code.
- A clear rule on accountability for agent-written code – normally the person who opens the pull request.
- Early agreement with works councils or staff representatives, where they exist, on whether and how usage data is analysed.

**Contracts and data protection:**

For each tool, establish where code and prompts go, how long they are kept and whether they are used for training. For Claude Code, Anthropic states that it does not train on code or prompts from [Team, Enterprise and API accounts](https://code.claude.com/docs/en/data-usage), keeps commercial data for 30 days by default, and offers zero data retention to qualifying Enterprise accounts. Cursor says that with [Privacy Mode enabled it will not train on your data](https://cursor.com/security), and team admins can switch it on for everyone. Whether that is sufficient for your code is a case-by-case assessment; this section is orientation, not legal advice. If source code must not leave your infrastructure at all, the options for running models yourself are covered under [sovereign AI](https://www.ruebstudio.de/en/sovereign-ai).

## How do you roll out coding agents step by step?

A staged rollout works best: a small pilot group, one repository, clearly scoped task types, and shared configuration under version control from day one. Add more repositories and people only once review and testing keep pace with the extra volume of changes.

1. **Assess the starting point.** Which repositories have reliable tests? Where do secrets live? Which tasks repeat – adding tests, upgrading dependencies, fixing bugs with a clear reproduction?
2. **Pick a tool and a contract.** One tool for the pilot, on a business account with clarified data terms – no personal accounts.
3. **Create the shared configuration.** `AGENTS.md` or `CLAUDE.md` with build and test commands, architecture rules and no-go areas; permission rules in each tool's settings file; everything committed and reviewed.
4. **Approve task types.** Start with work whose result is easy to verify, such as missing tests or well-described bugs. Architectural changes come later.
5. **Adapt review rules.** Small pull requests, agent involvement marked in the PR, tests green before a human reviews.
6. **Capture lessons.** A mistake the agent repeats should become a line in the project instructions or a technical block – not just a fix in one PR.
7. **Expand.** Bring in more repositories and people once the pilot is stable and the configuration has stopped changing every week.

On instruction length: Anthropic recommends [keeping each CLAUDE.md under about 200 lines](https://code.claude.com/docs/en/memory), because longer files use more context and reduce adherence. For Codex, the 32 KiB limit mentioned above applies. Short, checkable rules work better than long prose.

## What are the limits and risks?

The biggest team-level risk is not one bad change but a review process that cannot keep up. More pull requests, larger diffs and plausible-looking code tempt reviewers to cut corners. Add permissions that are too broad and knowledge that lives only in an agent session, and problems accumulate quietly.

**Review bottleneck.** When an agent produces a lot of code quickly, the work moves into review. Countermeasures: small PRs, mandatory tests before review, clear ownership. A separate guide in this topic area covers code review with AI agents in depth.

**Over-broad permissions.** An agent that may run any command with network access can install packages, send data elsewhere or delete files. Start with restricted modes – `workspace-write` in Codex, explicit `allow` lists in Claude Code – and widen them deliberately.

**Prompt injection through content.** Agents read issues, comments, dependencies and web pages. Hidden instructions in any of these can be followed. That is why technical controls matter more than written instructions.

**Loss of understanding.** If developers merge code they cannot explain, maintenance and debugging suffer later. Reviews should therefore also ask whether the PR author can walk through the change.

**When this approach does not fit:** repositories without tests, security-critical code without additional verification, and codebases that contractually must not leave your premises where no self-hosted option is available.

## How do you get started?

Start with one well-tested repository, a small group and a single tool. Write and commit the shared configuration in the first week, then after a few weeks look at how review times and defect rates have moved before you widen the rollout.

A short starting list:

- Choose a pilot repository with a green build and useful tests.
- Write an `AGENTS.md` with build, test and lint commands plus three to five key architecture rules.
- Enforce permissions technically: block secrets, limit execution to the workspace.
- Check branch protection and mark agent contributions in pull requests.
- After the pilot, revise the instructions based on the agent's most frequent mistakes.

If you would rather work through this with your team on your own codebase, a [hands-on workshop on agentic development](https://www.ruebstudio.de/en/workshop) can produce the configuration, permissions and review rules directly in your pilot repository. For the wider picture – roles, rules and accountability for AI across the organisation – see the page on a [fractional head of AI](https://www.ruebstudio.de/en/fractional-head-of-ai).

## Frequently asked questions

### Do we need separate instruction files for each tool?

Usually not. Codex and Cursor read AGENTS.md, and Claude Code reads it from version 2.1.277 when no CLAUDE.md is present. Add tool-specific files only for features a single tool offers.

### Is a line like 'never push to main' in CLAUDE.md enough?

No. Anthropic states that Claude Code treats CLAUDE.md as context, not enforced configuration. Anything that must never happen belongs in permission rules, hooks, sandbox settings or branch protection on your Git server.

### Will our source code be used to train models?

That depends on your contract. Anthropic's documentation says it does not train on code from Team, Enterprise and API accounts, and Cursor says the same when Privacy Mode is on. Check the terms of the exact plan you buy for every tool.

### Should the whole team use the same tool?

For a pilot, yes: shared configuration, training and review rules then only need to be built once. Later, several tools can coexist as long as project instructions and checks are the same for everyone.

## Sources

- [Anthropic: Claude Code – Settings files and precedence](https://code.claude.com/docs/en/settings)
- [Anthropic: Claude Code – How Claude remembers your project](https://code.claude.com/docs/en/memory)
- [Anthropic: Claude Code – Data usage](https://code.claude.com/docs/en/data-usage)
- [OpenAI: Codex – AGENTS.md](https://learn.chatgpt.com/docs/agent-configuration/agents-md)
- [OpenAI: Codex – Sandboxing](https://learn.chatgpt.com/docs/sandboxing)
- [Cursor Docs: Rules](https://cursor.com/docs/context/rules)
- [Cursor: Security](https://cursor.com/security)
- [DORA: State of AI-assisted Software Development 2025](https://dora.dev/research/2025/dora-report/)
