Back to skill

Security audit

autopilot

Security checks for vulnerabilities and agentic risk

Overview

This is a clearly disclosed autonomous coding workflow that can edit the working tree but does not hide behavior or publish changes on its own.

Install this only if you want an agent to make local code changes without checking in during the run. Use it in a clean branch or disposable workspace, review the final diff and any .claude/handoffs content before sharing, and avoid permission-bypass mode outside a sandbox.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (5)

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The skill explicitly instructs the agent to create a branch and to write handoff files, which are working-tree modifications, but it does not prominently warn the user up front that invoking this skill will mutate the repository even when no commit or PR is created. In a headless or hands-off context, that can surprise users, interfere with clean-working-tree assumptions, or trigger downstream automation on file changes.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
a destructive or irreversible step, missing access, an architectural or unimplementable
  spec, or three failed fixes on one behavior. Use this skill whenever the user says
  "autopilot", "/autopilot", "run task <id> autonomously", "work this task end to end
  without asking", "full autonomy on this", "do the whole task, skip commits and PR", or
  launches a headless run with a task id — even if they don't name the skill. Not for
  interactive plan approval (task-executor), a queue of tasks (goal-runner), or when
  commits or PRs should be created (create-pr).
Confidence
95% confidence
Finding
The skill is designed for autonomous execution 'without asking' and explicitly removes human approval gates for planning and execution. In a coding agent, that increases the chance of unintended code changes, risky assumptions, and propagation of errors before human review, especially in headless runs.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
## When to use this skill

- "autopilot task 12345" / "run task 12345 autonomously" / "/autopilot 12345"
- "work this end to end without asking me anything, skip PR and commits"
- A headless (`claude -p`) invocation naming a work item or task description.

Do **not** use when the user wants to approve the plan (`task-executor`), has a queue of tasks (`goal-runner`), or wants a commit or PR produced (`create-pr`).
Confidence
95% confidence
Finding
This invocation guidance encourages end-to-end operation with no user interaction, which is inherently risky in environments where the agent can edit code, run commands, and make assumptions. The surrounding skill makes this more dangerous because it couples autonomy with broad task execution across many other skills.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
## Examples

- **Headless work item.** "autopilot task 4711" → remote is `dev.azure.com` → `azure-devops` pulls #4711 with two screenshots (both viewed); baseline `47 passed` quoted; 4 increments, each red-then-green under `write-tests`; the diff adds an endpoint → `code-review`, `security-review`, `api-contract-review`, `ship-it` run, one blocker (missing authz) fixed and re-reviewed; report has Requirements 5/5 met, a Skills used table with quoted headings, 2 cited assumptions, a `conventional-commits` block. No commits.
- **Hard stop done right.** "run task 8912 end to end without asking" → task says "remove the legacy sync"; inspection shows production traffic still hitting it (log timestamps quoted). Destructive and contradicts the spec → hard stop after Phase 1, tree untouched, report names the one decision ("confirm the consumer at X is decommissioned").

## Anti-patterns
Confidence
91% confidence
Finding
The examples normalize unattended execution of substantial development tasks, reinforcing a no-questions model that can lead operators to overtrust autonomous changes. In practice this can cause users to launch the skill in contexts where hidden ambiguity, missing requirements, or security-sensitive edits should have required a checkpoint.

Session Persistence

Medium
Category
Rogue Agent
Content
- ❌ "Assumed camelCase keys — matches project conventions." (no instance cited)
   - ✅ "Assumed camelCase keys — every DTO in `src/api/dto/` uses them (`UserDto.ts:12`). Blast radius: one serializer line."
2. **Hard stops only.** Halt and report (never improvise) when the next step is destructive or hard to reverse (data deletion, force push, dropping schema objects, external side effects); access or credentials are missing; the task is architectural (Phase 0); every reading of the task contradicts the codebase expensively; or three fixes have failed on one behavior. The stop-vs-assume test: *would a wrong guess destroy data, publish something, or cost more to undo than redoing the task?* No → assume and log. Yes → hard stop, with the tree left at the last observed-green state and the one decision needed to resume.
3. **Never commit, push, or create PRs.** The deliverable is a verified working tree plus the report. The human gets the final gate.
4. **Scope is the task, exactly.** Adjacent problems go in "Found along the way", never in the diff.
   - ❌ Adding a `-j` alias because "it's consistent" when the task said `--json`. ✅ `--json` only; the alias idea goes in Found along the way.
5. **Unobserved is `not run`, never `passed`.** Every Evidence line carries a tag: `verified` (you ran it and quote the output), `inferred` (follows from a named verified fact), `assumed` (unverified; name what breaks if wrong). "Tests pass" is not "requirements met".
Confidence
76% confidence
Finding
Although the skill forbids commit/push/PR, it intentionally leaves a modified working tree and also supports persistence via handoff files elsewhere in the document. That creates session persistence of potentially sensitive task context and code changes on disk, which can leak information, confuse later sessions, or be picked up unintentionally by other tooling.

Static analysis

No suspicious patterns detected.