**Symptom:** You want Claude Opus 5.5 to review or assist with code in GitHub Actions, but you are unsure which permissions and runner to use. **Fastest safe fix:** Start with a restricted pilot, confirm the current model ID and Claude Code Action support in official documentation, and keep tests and human merge approval as separate gates.

This guide is for GitHub Actions maintainers adding AI review or coding assistance, AI Coding teams separating agent work from CI acceptance, and iOS or macOS teams deciding when Xcode requires a macOS Runner.

**Last updated September 25, 2026.** Model availability and release details are checked against [Anthropic’s Claude Opus 5.5 announcement](https://www.anthropic.com/claude-opus-5-5). Before rollout, verify the current model catalog, Action behavior, and security guidance in their official documentation.

Start with a read-only PR review

Treat review as the first deployment scenario, not as a shortcut to automatic merging. Claude Opus 5.5 can analyze a patch and explain potential issues, but a model response does not establish that the code is correct, that every relevant file was examined, or that a change is safe to merge.

Before adding the Action, confirm that the current model catalog exposes the model and copy its exact model identifier. Then confirm that the current Claude Code Action documentation supports passing that identifier through the documented inputs. The release announcement confirms availability; it does not, by itself, confirm that a particular Action revision accepts a particular model string. Check the [model catalog](https://www.anthropic.com/claude/opus) and the Action’s [configuration reference](https://github.com/anthropics/claude-code-action/blob/main/docs/configuration.md) at implementation time.

A safe pilot limits what the agent can read and where it can write:

- Provide the pull request diff and only the repository context needed to interpret it. - Send the response to a job summary or a review artifact first. If you want the Action to post a PR comment, grant the specific write permission needed for that operation and keep it separate from code-modification permissions. - Give the workflow only the token scopes its actual steps require. For a read-only review, begin with repository and pull-request read access; do not grant broad repository write access just because a later workflow might need it. - Record the model identifier, Action reference, prompt, and workflow run alongside the review result. This lets you investigate behavior after an update instead of comparing vague “AI review” outcomes.

A starter workflow should be treated as a template, not pasted unchanged. Replace the Action reference with a reviewed release or pinned commit, and confirm each input name in the current official usage and configuration documents.

```yaml name: AI pull request review

on: pull_request:

permissions: contents: read pull-requests: read

jobs: review: runs-on: ubuntu-latest steps: - name: Run Claude Code Action uses: anthropics/claude-code-action@ with: anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }} prompt: "Review the pull request diff. Report specific risks and file references. Do not modify files or approve the pull request." claude_args: --model ${{ vars.CLAUDE_MODEL_ID }} ```

The placeholder is intentional: do not assume an old example’s model value or Action reference remains valid. Check the current [usage documentation](https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md), confirm the documented model argument, and pin the exact reviewed reference your organization accepts. If the workflow only produces a summary, keep it that way during the pilot. Add comment-writing capability only after you have a clear reason and a permission review.

**Stop condition:** If the model ID is not present in the current catalog, or the Action’s current documentation does not confirm the needed input path, do not guess. Keep the workflow disabled until you validate a supported configuration.

Configure Claude Code Action without guessing

The answer to “Can Claude Code Action run Opus 5.5 in GitHub Actions?” depends on current Action and model support, not on the fact that both the model and the Action exist. The task’s stated release information places Claude Opus 5.5’s announcement on September 22, 2026, with availability through Claude Platform and other named platforms. For deployment, still verify the exact model identifier in the live catalog and confirm how the current Action accepts it.

Use this sequence before enabling a workflow:

- Open the current model catalog and copy the exact identifier. Do not infer it from a display name, a previous model’s naming pattern, or an old workflow. - Check the Action’s current usage and configuration docs for model selection, API key input, prompt configuration, and GitHub token handling. - Review the Action reference you intend to run. Prefer a reviewed, immutable commit reference if that matches your team’s dependency policy; record how you will update it. - Store API credentials as protected secrets. Keep them out of prompts, logs, checked-in files, and untrusted workflow inputs. - Run a controlled test on a repository and branch where the maintainers can inspect the event, permissions, logs, and resulting output. - Recheck the configuration whenever the model catalog or Action documentation changes.

For a deployment record, save a small, reviewable manifest with the workflow file, selected model ID, pinned Action reference, granted permissions, trigger type, and output destination. That record is more useful than a screenshot of a successful run: it shows which configuration was actually tested and gives your team a way to compare future changes.

Do not use “the action completed successfully” as evidence that the review was accurate. It shows that the workflow reached its completion state. It does not demonstrate complete defect detection, safe recommendations, or compatibility with your build environment.

Scope permissions for automated coding

Read-only analysis and code modification are different workflows. If you allow an agent to edit files, create commits, or update a pull request, first define the work it may perform and the repository state it may change. Do not treat a GitHub Actions job as a sandbox merely because it runs on a hosted runner.

For a trusted-branch coding task, make the boundary explicit:

- Trigger from a maintainer-controlled branch or another reviewed event. Define which users or workflows can initiate changes. - Limit the job to a disposable working directory or a narrowly scoped checkout. Avoid giving the agent access to unrelated repositories, deployment credentials, or production secrets. - Separate file changes from approval and merge authority. An agent-generated commit should still pass the repository’s normal review and required checks. - Restrict the token to the smallest set of operations required by the task. If the task needs to push a branch, grant that capability for the relevant job rather than granting broad write access to every workflow job. - Make credentials revocable and rotate them through the repository’s approved secret-management process. Check what is available to the job before running tools or scripts. - Preserve logs and the diff produced by the agent so a reviewer can compare the requested task with the actual change.

The [Claude Code Action security documentation](https://github.com/anthropics/claude-code-action/blob/main/docs/security.md) describes Action-specific security considerations. Read it alongside GitHub’s [secure-use guidance](https://docs.github.com/en/actions/reference/security/secure-use). Neither document makes your workflow safe by default: permissions depend on your event, token, checkout, tools, secrets, and repository settings.

**Stop condition:** If you cannot explain which files the agent may modify, which credentials it can reach, and who can start the job, keep it read-only. Do not upgrade permissions just to make an unclear workflow pass.

Handle external PRs as untrusted input

A pull request is not just a code diff. Its title, branch name, commit messages, file contents, and comments can all contain text an agent or script might interpret as instructions. The workflow must treat contributions from outside the trusted maintainer boundary as untrusted input.

For a public or shared repository, use a trigger and permission design that does not expose secrets or grant a contributor’s code write access. GitHub documents the risks of [securely using `pull_request_target`](https://docs.github.com/en/actions/reference/security/securely-using-pull_request_target); do not combine a privileged event with a checkout or execution of untrusted PR code as a convenience workaround. Confirm the exact event behavior in the current GitHub documentation before deciding how your workflow handles forks.

A safer operating pattern is to keep external contributions out of secret-bearing agent jobs by default. If your team needs AI analysis for those PRs, choose a workflow that has been reviewed for the event’s token and secret behavior, uses a deliberately limited credential path, and does not execute contributor-controlled scripts with privileged access. If that boundary cannot be guaranteed, ask a maintainer to initiate a separate reviewed run from a trusted context rather than silently widening the original workflow’s permissions.

Check the following before enabling external PR analysis:

- The event can receive untrusted PR content, but the job has no unnecessary write token or deployment secret. - The workflow does not run PR-controlled scripts under a privileged token. - The prompt tells the agent to treat repository text and comments as content to analyze, not instructions that override the task. - The workflow’s output channel is constrained. A comment or artifact must not be interpreted as an approval or merge command. - A maintainer can disable or cancel the run without needing to revoke unrelated project credentials.

Prompt wording is useful, but it is not a substitute for isolation. If a job has access to a secret or write token, instructions telling the model not to expose it are not an access-control mechanism.

Keep general CI deterministic

For a web or backend repository, keep the model task and the acceptance pipeline in separate steps with separately visible results. Claude Opus 5.5 can suggest a fix or identify a suspected regression. Linting, tests, builds, and repository policy checks determine whether the change passes the project’s defined checks.

A practical flow looks like this:

- Run the agent task and preserve its proposed diff or review output. - Run the repository’s normal lint, test, and build commands independently. - Make required status checks reflect those deterministic commands, not the model’s opinion. - Require the usual human review or protected-branch approval before merging. - If the agent changes files, run the checks against the final changed tree, not just the original pull request state.

Keep the job names and outputs distinct. For example, a workflow might show “AI review” and “Unit tests” as separate checks. A green AI review job means the agent completed its assigned task; it is not a test result. A green test job means the configured tests passed; it does not prove that every risk has been found.

This distinction also helps with incident review. If a regression reaches a branch, you can determine whether the failure came from agent suggestions, missing tests, a skipped check, or a human approval decision. Combining them into one vague “AI CI passed” status makes that investigation harder.

Choose a macOS Runner only for Apple toolchains

A model call does not require a Mac merely because Claude Opus 5.5 is involved. Text-only review, repository analysis, and CI tasks that use available non-Apple tools can run on an appropriate non-macOS environment. Choose a macOS Runner when the job must use Xcode, Apple SDKs, or other tools that require macOS.

The [GitHub-hosted runner documentation](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) describes the available runner environments. Verify the current image, installed Xcode version, and required SDKs when you configure the job; do not assume that a runner image contains the precise Apple toolchain your project needs. A runner label alone is not proof that the build can sign, compile, or publish your app.

Keep these boundaries separate:

- **Agent execution:** model analysis or proposed code changes. - **Xcode validation:** compilation, tests, and other Apple-toolchain checks. - **Signing and release:** access to signing material, store credentials, and publication authority.

The Xcode job should validate the actual changed code. Signing and release steps should use their own reviewed conditions and credential controls. A successful model run does not authorize signing, and a successful Xcode build does not automatically authorize release.

For a mixed repository, keep text-only review and platform builds in different jobs. This avoids reserving macOS capacity for tasks that do not need it and makes it clear which result depends on Apple tooling. For an iOS project, route only the Xcode-dependent checks to macOS; keep model-only review and platform-independent checks on the runner type that fits those tasks.

If you need a Mac environment for a temporary Xcode validation or a controlled CI experiment, compare the requirements with [MacWww’s available Mac options](https://macwww.com/buy.html). Review the service context on [MacWww](https://macwww.com/about.html) before choosing a setup. A rented Mac can be a better fit for a short-lived test environment than maintaining idle hardware, but it is not automatically the right choice for sustained, predictable heavy workloads or jobs that require physical access to a specific device.

Run the deployment checklist

Use this checklist before enabling the workflow for a team or repository:

- [ ] Confirm that Claude Opus 5.5 appears in the current Anthropic model catalog and record the exact identifier. - [ ] Confirm that the current Claude Code Action documents support for the model-selection method you plan to use. - [ ] Pin and record the reviewed Action reference; define who reviews future updates. - [ ] Start with a read-only job and the smallest permissions needed for its output. - [ ] Decide whether the workflow posts a summary, artifact, or comment. Grant comment-writing permission only if that output is required. - [ ] Verify that secrets and write tokens are unavailable to untrusted PR jobs. - [ ] Review the event trigger, checkout behavior, and every command that can execute repository-controlled content. - [ ] Keep model output separate from lint, test, build, merge, signing, and release decisions. - [ ] Route Xcode and Apple SDK checks to a verified macOS Runner; leave platform-independent work on an appropriate non-Mac runner. - [ ] Test failure handling: confirm how maintainers cancel a run, revoke credentials, and inspect a generated diff. - [ ] Enable the workflow for the intended scope only after reviewers can explain its permissions and stop conditions.

If any item remains unclear, narrow the pilot rather than adding permissions or changing runner type to silence the failure. A disabled or read-only workflow is preferable to an agent job whose trust boundary nobody can describe.

Move from pilot to controlled use

For GitHub Actions, the safest starting point is a read-only review with a verified model ID, a reviewed Action reference, and a clear output destination. Add automated edits only for trusted tasks with scoped credentials, and keep deterministic CI and human merge approval independent of model output. Use a macOS Runner when the job actually needs Xcode or Apple tooling—not simply because it calls Claude Opus 5.5.

If your current setup relies on a long-lived local Mac, a shared general-purpose runner, or a manually maintained Xcode machine, account for the operational cost: idle capacity, environment drift, and unclear separation between agent execution and signing credentials. MacWww’s Mac options may suit a temporary Xcode regression run or short-lived Apple-platform CI trial. For sustained high-volume builds, a permanent managed setup may be more appropriate; for text-only review, keep the workflow on a non-Mac runner.