Skip to main content
AI strategy

Claude Code in a business: what an AI developer agent can do, and what it requires

Claude Code is Anthropic's agentic developer tool: it reads the codebase, writes and changes code, runs tests and works in the terminal. Here is an honest review of what it can do in a business, and what it requires in security, governance and organisation.

Author:
Published: 31 July 2026
Last updated: 7 November 2026
Reading time: 20 min read

Claude Code in a business is Anthropic's agentic developer tool: it reads the entire codebase, fixes bugs and runs tests under human supervision, but requires access control, approval gates and a named person responsible before it gets access to production-adjacent systems.

Claude Code is Anthropic's agentic developer tool: an AI agent that reads your entire codebase, writes and changes code across files, runs commands and tests in the terminal and works together with your existing developer tools. For a business, that means that a large part of day-to-day development work (bug fixes, tests, refactoring, documentation, code review) can be delegated to an agent working under human supervision. But it also means giving a piece of software access to your code and your systems, and that makes demands: on access control, on approval gates, on audit trails and on someone in the organisation owning the responsibility. This article goes through both sides (what the agent can do, and what it requires) based on Anthropic's own documentation.

Claude Code is, according to Anthropic's official documentation, "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools": available in the terminal, as an IDE extension, as a desktop app and in the browser.

Let's start with the definition and work our way towards what most decision-makers actually ask: can we use it responsibly, and what do we need in place first?

What is Claude Code?

Claude Code isn't a chatbot you ask questions, nor an autocomplete function that suggests the next line of code. It is an agent: a program that is given a task described in plain language, plans for itself how to solve it, and then carries it out in several steps: reads files, writes code, runs it, sees the result and corrects it, until the task is solved or the agent needs input.

The difference is significant. A chatbot gives you an answer that you have to turn into action yourself. An agent acts itself: within the limits you have given it. That is what makes the agent category interesting for businesses, and it is also what makes the governance question pressing.

Where does Claude Code run?

According to the documentation, Claude Code runs on several surfaces that share the same underlying engine:

  • The terminal (CLI), the full version, where the agent works directly in the project folder on the developer's machine.
  • IDE extensions: VS Code and JetBrains IDEs (IntelliJ, PyCharm, WebStorm etc.) with visual diffs and context from the editor.
  • Desktop app, a stand-alone app with the ability to run several sessions side by side and schedule recurring tasks.
  • The browser: cloud sessions with no local setup, where the work runs in isolated, Anthropic-managed virtual machines.

Instruction files, settings and integrations carry across the surfaces. For a business, that means you can standardise one configuration and let employees choose the way of working that suits them.

The model behind

Claude Code is powered by Anthropic's Claude models, the same models that are available via Anthropic's API. According to Anthropic's enterprise documentation, the tool can also be run through cloud providers such as Amazon Bedrock, Google Cloud's Agent Platform (formerly Vertex AI) and Microsoft Foundry: we return to that under governance, because it's an important point for businesses with requirements on where data may flow.

What a developer agent can do in practice

What follows are the capabilities Anthropic itself documents, not a wish list. It's worth being precise here, because the marketing around AI agents is often far ahead of reality.

Reading and understanding a codebase

Claude Code can search and read an entire project: find relevant files, follow dependencies across modules and form a picture of the architecture. In practice that means a developer (or a technically interested manager) can ask questions like "where is user login handled in this system?" and get an answer that builds on the actual code, not on a general assumption.

This is often where businesses experience the first concrete value: onboarding new developers, understanding old code whose details no one remembers any more, and documenting systems that were never documented.

Writing and changing code across files

The agent can implement new features and fix bugs described in plain language. The documentation describes the workflow like this: the agent plans the approach, writes the code across several files and verifies that it works. For bug fixes you can paste in an error message or describe the symptom, after which the agent traces the problem through the codebase, identifies the cause and implements a fix.

The key word is "verifies". An agent that can run the code after writing it catches its own errors in a way that pure text generation never can.

Running tests and commands in the terminal

Claude Code works in the terminal and can run the commands a development project is built on: test suites, linters, build tools, package installation. Anthropic itself highlights the tasks developers typically put off: writing tests for untested code, fixing lint errors across a project, resolving merge conflicts, updating dependencies and writing release notes.

It sounds undramatic, but it's exactly the kind of work that swallows time in a development team, and that is rarely prioritised because it isn't new functionality.

Working with git and CI

The agent works directly with version control: it can stage changes, write commit messages, create branches and open pull requests. In a CI context, Claude Code can automate code review and issue triage via GitHub Actions or GitLab CI/CD, in other words run as part of the company's existing development pipeline, not just as an interactive tool on the individual developer's machine.

Scripting and automation

Claude Code follows the Unix philosophy: it can receive input via pipes, be run non-interactively in scripts and be chained with other tools. The documentation shows examples such as analysing log output or having the agent review changed files for security issues as part of an automated flow. On top of that come subagents: several agents working on different parts of a task at the same time, coordinated by a lead agent, and an Agent SDK for those who want to build their own agent applications on top of the same engine.

From developer tool to business tool

All of the above is interesting for a development team. But the real shift comes when the agent gets access to the company's systems and data, and this is where the category "developer tool" starts to become too narrow.

MCP: the agent's access to the company's systems

Claude Code supports the Model Context Protocol (MCP), an open standard for connecting AI tools to external data sources and systems. With MCP the agent can, according to the documentation, read design documents in Google Drive, update tickets in Jira, pull data from Slack or use the company's own internal tools.

That changes the calculation fundamentally. An agent that can only see code can help developers. An agent that can see code and the company's ticketing system, documentation and business data can carry out whole workflows: read the bug report in Jira, find the cause in the code, fix it, open a pull request and update the ticket. The chain from "problem discovered" to "solution ready for review" can in principle be run by the agent, with humans as approvers at the critical links.

Knowledge and standards: CLAUDE.md, skills and hooks

An agent is only as good as the context it works from. Claude Code has three documented mechanisms for giving it the company's knowledge:

  • CLAUDE.md: an instruction file the agent reads at the start of each session. This is where you put coding standards, architecture decisions, preferred libraries and review checklists. Anthropic recommends deploying these files both at organisation level (common standards for the whole company) and per repository.
  • Skills: packaged, reusable workflows that the team can share, e.g. a fixed procedure for review or deployment.
  • Hooks: shell commands that run automatically before or after the agent's actions, e.g. automatic formatting after every file edit or lint before commit.

Seen through a business's eyes, this is where the agent goes from "smart intern" to "employee who knows the house rules". And it's worth noting that Anthropic itself highlights investment in documentation as the most important recommendation for organisations rolling the tool out.

Developer use vs. business use

Claude Code: individual developer use compared with organised business use

Dimension Individual developer Business / organisation
Access Personal account, local files SSO, role-based permissions, possibly a cloud provider (Bedrock, Google Cloud, Foundry)
Configuration Personal settings and local CLAUDE.md Managed policy settings rolled out centrally + CLAUDE.md at organisation and repo level
System access Own machine and own repos MCP servers for Jira, Drive, Slack etc. configured by one central team and shared via version control
Security Standard permission model with manual approval Centrally enforced permissions that can't be overridden locally, plus sandboxing and deny rules
Overview Own session history Monitoring via OpenTelemetry metrics, audit logging in cloud environments
Responsibility The developer reviews everything personally Defined approval gates, a named person responsible, documented workflows

The point of the table isn't that the business column is "more advanced". The point is that it is governed: the same capabilities, but with centrally defined frameworks instead of individual choices.

Security and governance: what you should require

This section is the most important in the article if you're a decision-maker. An AI agent with write access to code and system access via integrations is a powerful tool, and powerful tools require frameworks. The good news is that Claude Code's security model is publicly documented, so you can assess it concretely instead of guessing.

The permission model: read-only as the starting point

According to Anthropic's security documentation, Claude Code uses "strict read-only permissions by default". When the agent wants to do more than read (edit files, run tests, execute commands) it explicitly asks for permission. The user controls whether an action is approved once or allowed automatically from then on.

On top of that come a number of built-in safeguards that are worth knowing when assessing the tool:

  • Working directory boundary: the agent can only write in the folder it was started in and its subfolders, not in parent folders without explicit permission.
  • Sandboxing of terminal commands: bash commands can be isolated with filesystem and network isolation.
  • Approval of network commands: commands that fetch content from the web (such as curl) aren't approved automatically, precisely because outside content is a classic attack route.
  • Fail-closed: commands that don't match an explicit rule require manual approval by default.

The documentation also describes specific safeguards against prompt injection, attacks in which malicious text in, say, a web page or a document tries to take over the agent's instructions. Among the safeguards are isolated context windows for web content, detection of suspicious commands (which require manual approval even if they were previously allowed) and input sanitisation. Anthropic is at the same time honest that no system is immune to all attacks, an honesty you should demand of every supplier in this category.

Enterprise controls: policy that can't be bypassed locally

For organisations the decisive question isn't what the individual developer can set, but what the security team can enforce. Here Anthropic documents three things worth noting:

  1. Managed settings: security teams can configure centrally governed permissions for what Claude Code may and may not do, and these can't be overridden by local configuration on the individual machine.
  2. Monitoring: usage can be monitored via OpenTelemetry metrics, so the organisation has insight into how the tool is actually used.
  3. Deployment choices: Claude Code can be run via Anthropic directly or through the company's existing cloud agreements (Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry) with the IAM policies, audit logs and billing trails that belong to the platform. Traffic can also be routed through the company's own proxy or an LLM gateway with centralised access control.

For cloud sessions (Claude Code in the browser) Anthropic documents further: isolated virtual machines per session, network access that is restricted by default and can be configured to specific domains, git push restricted to the current branch, and audit logging of all operations.

What you SHOULD require, a checklist

Whether it's Claude Code or another agent tool, a company should, in our assessment, require the following before agents get access to production-adjacent systems:

  • Access control: the agent's access follows the principle of least privilege. No standing write access to systems where it isn't necessary.
  • Approval gates: destructive or irreversible actions (deployment, deletion, outgoing communication) require explicit human approval, always.
  • Audit trail: it must be possible to document what the agent has done, when and at whose instigation. No log, no agent.
  • Central policy: security rules are defined in one place and can't be bypassed by the individual user.
  • Review of output: code written by an agent is reviewed to the same standard as code written by humans. Anthropic puts it unambiguously itself in the documentation: you are responsible for reviewing proposed code and commands before you approve them.

The last point reaches beyond the technology: for Danish companies the regulatory framework also comes into play. We have written a walkthrough of what the EU AI Act means for Danish businesses, which is relevant background reading when you define your internal AI policy, including the requirements on human oversight and documentation.

What it requires of the business

The technology is the easy part. What decides whether an AI developer agent creates value or frustration is three organisational preconditions.

Data access and documentation

An agent without context guesses. An agent with access to up-to-date documentation, coding standards and the right systems works. Concretely that means:

  • Written-down standards: if your coding standards and architecture principles exist only in the heads of two senior developers, they need to be written down, in Claude Code's case in CLAUDE.md files that the agent reads automatically.
  • Tidy data sources: if the agent is to work with business data via integrations, the same rule applies as for all automation: garbage in, garbage out. Our guide to CRM data hygiene is about sales systems, but the principle is identical: data quality is the foundation under any automation.
  • Access that is thought through: which systems may the agent read from? Which may it write to? Who decides?

Clear workflows

An agent needs well-defined tasks with well-defined limits. "Fix this bug and write a test that proves the fix" is a good task. "Make our codebase better" is not. Companies that get the most out of agentic tools typically define:

  • Which types of task the agent may take on independently (tests, lint, documentation, minor bug fixes)
  • Which require human plan approval first (new features, architecture changes)
  • Which are completely outside the agent's area (security-critical code, production deployment without review)

Anthropic itself recommends a gradual approach: let new users start with questions about the codebase and minor bug fixes, ask the agent to lay out a plan, and give feedback along the way, and only let the agent work more independently as the team understands the way of working. That matches our experience with all automation: maturity comes in steps. The same principle applies, incidentally, outside the development department; see our walkthrough of what CRM automation is, and how to get started.

A person responsible

The most important single decision: appoint one person who owns the agent setup. Not a committee, not "the team", one person who:

  • Owns the configuration (permissions, integrations, instruction files)
  • Keeps track of what the agent is used for, and where it fails
  • Is the escalation point when something goes wrong
  • Maintains the documentation the agent works from

Without a person responsible, the configuration decays, permissions drift, and no one notices until something goes wrong. With a person responsible, the agent becomes a system the business governs, not an experiment that drifts.

Use cases: agencies and in-house development teams

Where does an AI developer agent create concrete value, then? Here are the patterns we assess as most realistic, based on the documented capabilities, not on promises.

For agencies and consultancies

  • Taking over other people's codebases: agencies often inherit code from previous suppliers. An agent that can read and explain an unfamiliar codebase shortens the road from takeover to productivity.
  • Maintenance across many client projects: dependency updates, security patches and lint cleanup are repetitive work that scales poorly with people and well with agents, with review as the gate.
  • Documentation as a deliverable: the agent can generate and maintain technical documentation of what it builds, something customers ask for and agencies rarely get round to.
  • Consistent quality: shared skills and instruction files across projects mean the house's standards go with every project, even when the team changes.

For in-house development teams

  • Reducing technical debt: the test coverage and cleanup that never get prioritised can be run as ongoing agent tasks.
  • Automated code review in CI: the agent as an extra reviewer on every pull request, not instead of human review, but before it, so humans spend their time on what matters.
  • Internal tooling: small tools and scripts the business asks for, but that never reach the top of the backlog.
  • Bridging to business systems: via integrations the development work can be linked to the systems the rest of the business lives in. For companies that work systematically with their go-to-market engine, it's the same way of thinking as in Revenue Operations: silos are broken down by connecting the systems, not by building more of them.

Limitations and honest caveats

No vendor-independent review is complete without this section. Here is what you need to be honest about:

The agent makes mistakes. Language models can write code that looks right but is wrong, or fix one problem and introduce another. The ability to run tests reduces the risk markedly, but doesn't remove it. Review isn't optional.

Quality depends on context. In a well-structured codebase with good tests and clear documentation the agent works well. In a messy codebase without tests the results are more mixed: the agent inherits the codebase's weaknesses, just as a new employee does.

Prompt injection is a real attack surface. When an agent reads outside content (web pages, documents, emails) that content can try to manipulate it. Claude Code has documented safeguards, but Anthropic itself writes that no protection is complete. Treat the agent's access accordingly.

Costs need managing. Agentic work uses considerably more model capacity than simple chat requests, because the agent reads, thinks and iterates. Without budgets and monitoring, usage can come as a surprise. The tools for managing it exist (gateways, dashboards, central quotas), but they have to be put to use.

The human is still the bottleneck, deliberately. Approval gates and review mean the agent doesn't make the organisation infinitely faster. That isn't a bug; it's the price of control. Companies that remove all gates to maximise speed have misunderstood the risk picture.

Organisational immaturity beats technology. If no one owns the setup, no one maintains the instructions, and no one follows up on output quality, the result gets worse over time, however good the tool is.

Getting started: a sensible order

For a company that wants to try an AI developer agent seriously, a sensible path looks like this:

  1. Start small and read-only. Let a small team use the agent for codebase questions and understanding, read-only work where the risk is minimal and the value immediate.
  2. Write the context down. Establish instruction files with coding standards and architecture principles before you scale. It's the best-documented lever for quality.
  3. Define gates. Decide explicitly which actions require approval, and configure the permissions accordingly, centrally if you have several teams.
  4. Appoint the person responsible. One person owns configuration, follow-up and escalation.
  5. Expand gradually. From reading to tests and small tasks, from small tasks to features with plan approval, from one integration to several, as trust and experience grow.

Claude Code and Agent360

Finally, an open declaration of our own standpoint: Agent360 helps businesses implement AI, and we are currently building Agent360 OS, where each business can get its own instance; it has not been released yet. If the question "what could an agent do with access to our systems?" arose along the way in this article, it's a question we'd gladly talk with you about.

Frequently asked questions

Q: Is Claude Code the same as ChatGPT or a chatbot?

No. Claude Code is an agentic tool: it carries out tasks in several steps (reads code, edits files, runs commands and verifies the result) rather than only generating text answers. A chatbot gives you an answer you have to turn into action yourself; an agent does the work within the limits you approve.

Q: Can Claude Code change things in our systems without approval?

Not by default. According to Anthropic's documentation, Claude Code works with read-only permissions as the starting point and asks for explicit permission before it edits files or runs commands that can change the system. Organisations can in addition enforce central policies (managed settings) that the individual user can't override locally.

Q: What is MCP, and why is it important for businesses?

MCP (Model Context Protocol) is an open standard for connecting AI tools to external systems and data sources, e.g. Jira, Google Drive or the company's own internal tools. It matters because it is the bridge from "AI that helps with code" to "AI that carries out whole workflows across the company's systems". At the same time, that is precisely where access control and governance become decisive.

Q: Can we run Claude Code through our existing cloud agreement?

Yes. Anthropic documents deployment via Amazon Bedrock, Google Cloud's Agent Platform (formerly Vertex AI) and Microsoft Foundry in addition to Anthropic's own plans, and traffic can be routed through the company's own proxy or an LLM gateway with central access control, usage overview and the audit mechanisms that belong to the cloud platform.

Q: Does an AI developer agent replace our developers?

No: it shifts their time. The agent takes over repetitive work (tests, lint, dependencies, documentation, first drafts of fixes), while the developers keep responsibility for architecture, review and the decisions that require business understanding. Anthropic's own documentation is clear that the human is responsible for reviewing and approving the agent's work.

Q: What is the most important thing to have in place before we roll out an agent?

Three things: written-down context (coding standards and documentation the agent can work from), defined approval gates (which actions require a human yes), and one named person responsible who owns the configuration and follows up. The technology can be installed in an afternoon; the organisational foundation is what decides the result.

#Claude Code #AI agents #Developer tools #AI governance #Security

What takes up your time?

Write down the task that takes up the most time. We reply whether it is worth building, and we say so if it is not.