Operating manual for a Claude Code agency

01 · Introduction

What automizeyourcompany actually is

A runtime for agency work inside Claude Code: roles, rituals and assets you can invoke, not a collection of prompts.

Most "AI for agencies" content stops at prompt libraries. This is different. The package is a self-contained .claude/ workspace plus an opinionated file layout on top of it. When you open it with the Claude Code CLI, you get a functioning studio:

• Twelve subagents covering the roles of a modern digital agency — strategy, delivery, engineering, design, growth, QA and DevOps — each with its own system prompt, tool allowlist and model profile.
• Five skills that encode transversal know-how (prompt engineering, brand voice, SEO + GEO, design systems for AI builders, technical documentation).
• Slash commands that choreograph the subagents into end-to-end workflows: onboarding a client, kicking off a project, shipping a landing, launching a campaign, running a codebase review.
• A client workspace pattern — one folder per client, with briefs, projects, decisions log and status reports — so institutional memory is versionable, searchable and handoverable.
• Templates for proposals, service contracts and email cadences, plus reference MCP configuration for Linear, Notion, Slack, GitHub, Stripe, Figma and more.

02 · Requirements

Requirements & prerequisites

What you need on your machine before installing. Nothing exotic, but everything should be current.

Experience with modern agency tooling is assumed: issue tracking (Linear, Jira), docs (Notion, GitBook), design (Figma), shipping frontends (Vercel, Netlify, Cloudflare), hosting backends (Fly, Railway, AWS), payments (Stripe) and analytics (Plausible, GA4). You do not need all of them, but the system is designed around those primitives.

03 · Installation

Installation

Fifteen minutes from download to first subagent running in your own workspace.

After purchase you receive a signed download URL for automatize-your-company-v1.0.zip together with your license key. The process is identical on macOS, Linux and Windows (WSL).

1. Prepare your workspace

Create a dedicated directory. We suggest one top-level folder you will use for every client you onboard.

mkdir -p ~/workspace/agency
cd ~/workspace/agency

2. Unzip the package

Extract the archive in place. It will create a complete .claude/ directory plus clients/, docs/, workflows/, templates/ and mcp-config/.

unzip ~/Downloads/automatize-your-company-v1.0.zip -d .
ls -la

3. Install the Claude Code CLI

npm install -g @anthropic-ai/claude-code
claude --version

4. Authenticate

On first run, Claude Code will prompt you for authentication. You can either sign in with your Claude account or provide an Anthropic API key via ANTHROPIC_API_KEY.

claude

5. Verify the workspace

From inside the agency folder, run claude and ask it to list the available subagents. You should see the twelve roles described further down in this document.

04 · First session

Your first session

A ten-minute warm-up that teaches you how the subagents, commands and client workspaces interact.

1. Open a terminal inside the agency folder and run claude.
2. Ask: "List the subagents available in this workspace and summarise each in one line." Claude Code will read .claude/agents/ and report back. This confirms the workspace is wired correctly.
3. Run /onboard-client. You will be asked for a client slug and a few essentials. The command clones clients/_template/ into clients/<slug>/, fills CLIENT.md, creates a decisions.md log and registers the client in clients/INDEX.md.
4. Run /new-project on the same client to create a numbered project folder with charter, backlog and risk log.
5. Try /build-landing. You will watch the CEO-strategist, marketing-strategist, copywriter, UI/UX designer, claude-designer, CTO, frontend and QA subagents hand work to each other in sequence.

05 · Architecture

How the system is built

Three layers that fit together: the cognitive layer, the procedural layer and the memory layer.

Understanding the architecture makes every subsequent decision — whether to add a subagent, a skill or a slash command — obvious.

Cognitive layer · subagents and skills

Subagents are the people of the agency. They carry role-specific judgement, tone, deliverable expectations and tool allowlists. Skills are the craft knowledge any subagent can reach for: a backend developer and a QA engineer can both call documentation, a copywriter and a marketing strategist can both call brand-voice.

Procedural layer · slash commands and workflows

Slash commands are entry points for recurring processes. Internally, they orchestrate one or more subagents via the Task tool, reading context from the client folder and writing deliverables back into it. Workflows (the workflows/ folder) are longer-form, human-readable recipes that sit above the commands — they describe the full client lifecycle, from pre-sales to post-launch.

Memory layer · the client workspace

Every decision, brief, proposal and status report is a file in the repository. The decisions.md log in particular is the backbone of institutional memory: it is where "why did we pick this database?" lives, three sprints and two handovers later. This is what makes the system safe to run at scale.

06 · Directory structure

Directory structure

The package is deliberately flat and readable. Here is what ships out of the box.

.
├── CLAUDE.md                 # workspace constitution
├── README.md                 # overview & quick start
├── CHANGELOG.md              # semver-tracked changes
├── LICENSE.md                # commercial license terms
├── .claude/
│   ├── agents/               # 12 subagents (role system prompts)
│   ├── skills/               # 5 skills (SKILL.md per capability)
│   └── commands/             # 8 slash commands
├── clients/
│   ├── INDEX.md              # registry of active clients
│   └── _template/            # cloned on every /onboard-client
├── docs/                     # long-form documentation in IT · EN
│   ├── en/
│   ├── it/
│   ├── fr/
│   ├── de/
│   └── es/
├── examples/
│   └── client-example-acme/  # fully populated reference client
├── mcp-config/
│   ├── mcp.example.json      # reference MCP server config
│   └── README.md             # how and where to apply it
├── templates/
│   ├── proposals/
│   ├── contracts/
│   └── emails/
├── team-roles/               # aggregated job descriptions
└── workflows/                # 4 end-to-end operating workflows

07 · Constitution

CLAUDE.md — the workspace constitution

A single Markdown file that grounds every subagent in the same operating principles.

CLAUDE.md at the root of the workspace is read by Claude Code on every session. It declares the agency's mission, the roles, the skills, the commands, the languages you support and the non-negotiable operating principles (confidentiality, traceability, client-language output, production-readiness).

You are expected to tailor it: add your own values, your preferred tech stack, the clients you do not take, the review gates you enforce before anything ships. Every edit compounds: the next /new-project will inherit the new rules automatically.

08 · Team

The twelve subagents

Role-specific collaborators with their own system prompts, models and tool allowlists. Invoke them by name or let a command orchestrate them.

Each file in .claude/agents/ is a role. The frontmatter declares name, description, tools and model (Opus for strategic roles, Sonnet for operational ones). The body is the system prompt: responsibilities, tone, required deliverables, hand-off points.

Invoking a subagent

You do not usually call a subagent by hand — slash commands do it for you. When you want to, simply ask Claude Code to delegate:

Ask the cto-architect subagent to review the data-layer choices
in clients/acme/projects/003-rebuild/decisions.md and challenge them.

09 · Skills

Skills — transversal craft

Composable competencies any subagent can reach for. They live in .claude/skills/ and are activated on demand based on the task at hand.

Anatomy of a skill

Each skill is a folder in .claude/skills/ containing at least a SKILL.md. The description field in the frontmatter is what Claude Code reads to decide when the skill applies — it is a condition, not a summary. Be explicit about the scenarios.

---
name: brand-voice
description: Use when you need to define a tone of voice, write copy in a
  brand's voice, audit consistency, or translate while preserving voice.
---

10 · Commands

Slash commands

Opinionated entry points for recurring agency workflows. Each command orchestrates subagents, reads and writes files in the client folder, and leaves auditable artefacts behind.

Customising commands

Commands are plain Markdown files in .claude/commands/. The frontmatter declares the allowed-tools list; the body is the instruction set the model executes. You are expected to edit them — for instance, to add your own QA gates inside /build-landing or to change the proposal template used by /generate-proposal.

11 · Workflows

Operating workflows

Human-readable recipes that describe how the agency runs end-to-end. They reference commands and subagents, and double as onboarding material for new team members.

Workflows are the contract between you and your team. They are the reason the system scales beyond one person: anyone joining the agency reads a workflow and immediately knows what the default operating procedure is.

12 · Operations

Client management

One folder per client, a strict template, and a decisions log that outlives staff rotation.

Shape of a client folder

clients/<slug>/
├── CLIENT.md               # identity, contacts, stack, constraints
├── decisions.md            # append-only log of strategic/technical decisions
├── briefs/                 # discovery, brand voice, positioning
│   ├── discovery-questions.md
│   └── brand-voice.md
├── projects/
│   ├── INDEX.md            # registry of projects for this client
│   ├── 001-audit/
│   │   ├── charter.md
│   │   ├── backlog.md
│   │   ├── risks.md
│   │   ├── deliverables/
│   │   ├── research/
│   │   └── status-reports/
│   └── 002-landing/
│       └── ...
└── reports/                # weekly/monthly/yearly status reports

Operating rules

• One client, one folder. Never share files across clients. The system enforces this through the folder contract; respect it.
• Decisions are append-only. Never rewrite history in decisions.md. Correct yourself with a new entry that references the previous one.
• Status reports live in the client folder. Weekly reports become the single source of truth for that client.
• Everything is Markdown, everything is versioned. git log becomes the audit trail you never have to build.

13 · Deliverables

Templates & deliverables

Starting points for the outputs clients actually pay for. Tailor them once, reuse them forever.

The examples directory is worth reading in full once. It shows, on a fictional client, how the pieces compose: a discovery brief drives a charter; the charter drives the backlog; the backlog drives weekly reports; the decisions log explains every non-obvious choice. This is the minimum bar the system assumes you operate at.

14 · Integrations

MCP integrations

Plug Claude Code into the rest of your delivery stack. Ship from the command line, not from a patchwork of copy-paste.

The mcp-config/ folder ships a reference configuration covering the servers most agencies need. You apply it either in your user-level ~/.claude/mcp_settings.json or in a workspace-level .mcp.json. See mcp-config/README.md for the trade-offs.

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": { "LINEAR_API_KEY": "REPLACE_ME_LINEAR_API_KEY" }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "REPLACE_ME_GITHUB_TOKEN" }
    }
  }
}

15 · Extending

Extending the system

Add what your agency is missing. The system is designed to be modified, not just used.

Adding a subagent

1. Create .claude/agents/<role>.md with frontmatter: name, description (start with "Use when…"), tools, model.
2. Write the system prompt as if you were writing a one-page job description: mission, responsibilities, deliverable standards, tone, when to hand off.
3. Reference the new role in CLAUDE.md and, if it participates in a workflow, in the relevant command file.

Adding a skill

1. Create .claude/skills/<skill>/SKILL.md. The description should describe the condition under which the skill is useful.
2. Keep the body short and operational: inputs, outputs, step-by-step, references. A skill is not a textbook — it is a checklist that converges.
3. Validate by asking a subagent to perform a task the skill should cover; verify it pulls the skill in.

Adding a slash command

1. Create .claude/commands/<name>.md. Declare allowed-tools explicitly.
2. Describe inputs required from the user, subagents to orchestrate (via Task), artefacts to produce and success criteria.
3. Test the command end-to-end on the example client before wiring it into a real workflow.

16 · Governance

Quality & governance

The guardrails that make the system safe to run at agency scale.

• Always version-control the workspace. Every session is a diff; every diff is reviewable.
• Review before you ship. Subagents are senior collaborators, not infallible ones. Treat their output like a pull request.
• Keep secrets outside the repository. Tokens, client credentials and signed contracts live in a vault, not in Git.
• Record decisions, not opinions. decisions.md is the one file that must be exemplary in every client folder.
• Audit periodically. Every quarter, run /review-codebase on your own workspace: you will find drift, and drift compounds.
• Respect the model. Do not over-stuff CLAUDE.md or any single system prompt. Precision compounds; verbosity does not.

17 · Support

Troubleshooting

Fixes for the issues we see most often in production deployments.

A subagent is ignored

The frontmatter description should start with "Use when…" or a similar conditional phrase. Claude Code matches subagents by activation condition, not by name alone. If a role is not being picked up, rewrite its description to describe a scenario rather than a title.

A slash command does not appear

Make sure you are in the agency root when you launch Claude Code, and that the file lives exactly in .claude/commands/ with a valid frontmatter block. Restart the CLI after renaming command files.

"Tool not allowed" errors

Check the tools (subagent) or allowed-tools (command) list. Every tool used inside the body must be declared.

MCP server connects but returns nothing

Test the server standalone with npx -y <server> and the same environment variables you set for Claude Code. Most "silent" issues are invalid tokens or missing scopes.

The output is in the wrong language

The system defaults to the client's language as declared in CLIENT.md. If a deliverable comes back in the wrong language, set language explicitly in the client profile and re-run the command.

18 · Upgrading

Upgrading between versions

How to take a new release without losing your customisations.

1. Commit your current state. Tag it: git tag pre-upgrade-YYYY-MM-DD.
2. Download the new archive and extract it into a scratch directory — not on top of your workspace.
3. Diff the new .claude/ against yours. Port improvements you want to keep; leave your customisations untouched.
4. Update CHANGELOG.md with a short note about what you merged and why.
5. Run /review-codebase on the workspace and spot-check one real client folder before the team goes back to delivery.