Agentic Build Systems: Patterns Across Claude Code Projects

Pattern 1: Local terminal session

The default Claude Code build starts in a repository. Claude reads files, edits code, runs commands, writes tests, and works with git while the human keeps review authority. This is the simplest pattern and the one most public demos resemble.

It works best when the repo already has runnable checks and clear conventions. Without tests, examples, or a project memory file, the agent has less friction but also less feedback.

Pattern 2: GitHub workflow

Claude Code GitHub Actions turns issues and pull requests into an automation surface. A mention can ask Claude to analyze code, create pull requests, implement features, or fix bugs while following repository standards.

This pattern matters because it creates reviewable artifacts. The agent is not just changing local files; it is producing branches, diffs, comments, and pull requests that fit the existing engineering workflow.

Pattern 3: MCP-connected operations

MCP turns Claude Code from a codebase-only agent into an agent that can read and act on external systems. Anthropic examples include issue trackers, monitoring data, databases, designs, Gmail drafts, and webhook-driven sessions.

The Ramp case shows why that matters. Incident response and ticket-to-code workflows improve when the agent can query the systems where the real context lives.

Pattern 4: Hooks, plugins, and packaged workflows

Hooks let teams run commands at key lifecycle points: after edits, before commands, when Claude needs input, or when context should be injected. Plugins package slash commands, agents, MCP servers, and hooks into shareable bundles.

Public templates in the gallery are mostly attempts to turn one developer's Claude Code setup into a repeatable operating environment. That is the transition from personal workflow to build system.

Pattern 5: SDK agents and fleet execution

Claude Agent SDK exposes the same agentic building blocks behind Claude Code: tools, hooks, subagents, MCP, permissions, and sessions. Spotify's migration agent is the flagship public example of this pattern.

The SDK pattern is most appropriate when local sessions are not enough: repository fleets, scheduled migrations, background workers, or domain-specific agents with explicit orchestration.

Pattern 6: Browser and desktop agent surfaces

Two surfaces outside the repository now produce build artifacts. Claude in Chrome is generally available on every paid Claude plan and takes autonomous actions in the browser behind a safety classifier, with domain allowlists for enterprise administrators. Claude Cowork hands an agent a goal and a set of folders and tools, runs multi-step work unattended or on a schedule, and returns finished files for review; Anthropic describes it as using the same agentic approach as Claude Code, aimed at non-coding knowledge work.

For this gallery the distinction is evidential, not tribal. A Claude Code build leaves commits, diffs, and pull requests. A Chrome or Cowork build leaves documents, spreadsheets, decks, and a visible step log, which is weaker for reproduction and stronger for showing what the agent actually touched. A build note should say which of those trails exists before quoting any outcome.

Anthropic also notes that default effort differs by surface, with Fable 5.1 running at High effort in Claude Code and Medium on Claude.ai and in Cowork. That is a reason to record the surface next to the result rather than treating all Claude output as one substance.

• Claude Code and the Agent SDK: version-controlled artifacts, easiest to verify.
• Claude Code on the web: isolated cloud environments with pull requests as output.
• Claude in Chrome: autonomous browser actions on paid plans, gated by a safety classifier.
• Claude Cowork: scheduled and unattended knowledge work over folders and connected tools.

How Anthropic's own teams build

Anthropic publishes a set of internal examples that read as a catalogue of these patterns in one company: product engineers using Claude Code for tests and reviews, infrastructure teams using it to scan incidents, designers moving from mock to code, data scientists building React visualizations, and security and documentation teams using it for codebase discovery.

The examples are useful precisely because they are unglamorous. They show the same tool absorbed into the intervals where a human would otherwise be doing lookup, scaffolding, or first-pass triage, which is the shape almost every credible build in this gallery shares.

What not to copy blindly

A mature Claude Code build system is partly technical and partly editorial. The team must know what good output looks like, what evidence should be preserved, what commands are safe, and where agent autonomy should stop.

That is why the gallery treats "built with Claude Code" as a claim to verify, not a magic label. The credibility comes from artifacts, tests, deployment context, source links, and maintenance history.