The agentic way of working: an operating model for teams

Set up three things before you hand a coding agent real work: the context it reads every session, the limits on what it may do without a person, and a check that tells it when the work is done. This page turns those three things into an operating model your team can adopt in 30 days, with the files, prompts and settings to copy.

The agentic way of working is a team habit, not a product. You describe an outcome, a coding agent such as Claude Code, OpenAI Codex, GitHub Copilot or Cursor plans and makes the change, and you review evidence instead of typing every line. The model has three parts.

• Right context. The agent reads standing instructions at the start of every session: a CLAUDE.md or AGENTS.md file with the build commands, conventions and rules it cannot work out from the code. Procedures it needs only sometimes live in skills, which load when a task matches them.
• Right constraints. Permission rules decide what runs without asking, what needs a person and what never runs. Hooks enforce the rules that must hold every time, such as blocking edits to secrets. CI gates and branch protection stop unreviewed code from reaching main.
• Reliable verification. Every change ends in a check that returns pass or fail: a test suite, a build, a linter, an eval, a screenshot compared with a design. A second agent with a fresh context reviews the diff, and a person reviews the pull request.

One loop runs on top of these parts for every change: plan, take small verifiable steps, verify, review, ship.

Two rules keep the model safe. People decide anything irreversible: merges, deploys, migrations, deletions, payments and messages that leave the company. And recurring work moves to routines, scheduled agents whose output is a pull request or a report that someone reviews.

Use this model when your team changes code, configuration, docs or data pipelines every week and you can check the result automatically. It pays off most on four kinds of work.

• Repeated changes with a clear check. Dependency bumps, lint fixes, an API migration across 50 files, tests for an untested module.
• Bug fixes with a reproducer. The agent writes a failing test first, then the fix, then shows the test passing.
• Investigation. Reading an unfamiliar codebase, tracing one request end to end, finding why a test fails one run in ten.
• Recurring chores. A daily CI digest, a CVE sweep three times a week, docs that drift from the code.

It fits less well in these cases.

• You cannot verify the result. Output with no test, build or reviewer behind it is a guess. Write the check first, or keep the task manual.
• The decision is the work. Choosing an architecture, a price or a vendor is judgment. Let the agent gather facts and draft options, then decide yourself.
• The data must stay under your control. Customer PII, payroll, unreleased financials and secrets do not belong in a prompt on a consumer plan. Use a business plan whose terms exclude training on your data, a redacted extract, or a local model, and block secret files with deny rules.
• The change is one line you can type faster than you can describe it.

Every coding agent runs the same loop. Claude Code's documentation names three phases: gather context, take action, verify results. Claude searches files, edits code, runs the tests, reads the output and goes around again until the task is done or you interrupt it. Each tool call returns information that decides the next step.

Your operating model plugs into that loop at fixed points.

• Before the loop. CLAUDE.md or AGENTS.md, the list of skill descriptions and the permission mode load when the session starts.
• Inside the loop. Permission rules and PreToolUse hooks run before each tool call, and PostToolUse hooks run after it. A hook that blocks a call sends its reason back to Claude, which adjusts.
• At the end of a turn. A Stop hook or a /goal condition can send Claude back to work until the tests pass.
• After the loop. CI, a reviewer and branch protection decide whether the change ships.

The agent does the typing. You own the context, the limits and the definition of done. Instructions in CLAUDE.md shape what the agent tries to do, but Claude Code enforces only permission rules, hooks and permission modes, so anything that must never happen belongs there and not in prose.