Skip to main content
Agent skill

Pyobfus Review

Review a Python project for source-protection readiness without changing anything: what would break under obfuscation, which framework preset fits, which files the current config already excludes, and exactly which artifacts a build would emit. Use when the user asks "is this safe to obfuscate?", "what would protecting this break?", "review before we ship", or wants a pre-merge / CI check. Read-only by design — it never obfuscates, never writes deliverables, and never runs project commands. To actually produce a protected build, use the pyobfus-protect skill instead.

Get started

Get the complete skill folder, including its scripts and reference files.

When to use this skill

Use Pyobfus Review when an AI agent needs a reusable SKILL.md workflow for this job: Review a Python project for source-protection readiness without changing anything: what would break under obfuscation, which framework preset fits, which files the current config already excludes, and exactly which artifacts a build would emit. Use when the user asks "is this safe to obfuscate?", "what would protecting this break?", "review before we ship", or wants a pre-merge / CI check. Read-only by design — it never obfuscates, never writes deliverables, and never runs project commands. To actually produce a protected build, use the pyobfus-protect skill instead.

When not to use it

Skip Pyobfus Review when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/pyobfus-review
# Save SKILL.md to ~/.claude/skills/pyobfus-review/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/pyobfus-review/SKILL.md. For a shared project, commit the folder at .claude/skills/pyobfus-review/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Pyobfus Review skill for this task: Use Pyobfus Review when this documented workflow matches the task. Confirm any required inputs or files before making changes.

What supports this recommendation?

69/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
77/100
Practical detail
68/100
Source evidence
52/100
Source signals
72/100
Model compatibility evidence
  • claudeinferred

    The skill text mentions Claude or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotinferred

    The skill text mentions Copilot or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# Review a Python project with pyobfus (read-only)

Your job: tell the user what protecting this project would cost them, before anyone changes a byte. You produce a judgement, not an artifact.

## Boundary — read this before running anything

This skill is read-only. Within it:

- **Never** run an obfuscation build, not even into a temp directory. - **Never** write, move, or delete project files. `--check`, `--dry-run` and `--sarif` are the only pyobfus modes you use here. `--sarif PATH` writes one report file, so only use it when the user asked for CI output and name the path they chose. - **Never** run the project's own commands (tests, entry points, install steps). Nothing in a review needs to execute the user's code. - If the user actually wants a protected build, say so plainly and switch to the **pyobfus-protect** skill. Do not quietly start building.

## Step 1 — scan

Prefer the MCP tool if the `pyobfus-mcp` server is connected:

``` check_obfuscation_risks(path="src") ```

Otherwise use the CLI (`pip install pyobfus`):

```bash pyobfus --check src/ --json ```

Both return the same shape: `severity_counts`, per-finding `file`/`line`/ `category`, detected `frameworks`, a `suggested_preset`, the `effective_config` that was applied, and the files that config already excludes.

The scan is config-aware by default: it reads the project's `pyobfus.yaml` and reports findings that the configuration already mitigates separately from the ones that still stand. Do not present a mitigated finding as an open risk.

**The two front ends differ on network access, so check which one you are using before telling the user anything about it.** The CLI's `--check` runs the dependency-hallucination advisory **by default**, which looks each declared dependency up on PyPI; pass `--offline` to skip it. The MCP tool is the opposite: it makes no network call unless you pass `verify_dependencies_online=true`. If the user is on a restricted network or cares that nothing leaves the machine, say `--offline` explicitly.

## Step 2 — preview what a build would produce

```bash pyobfus src/ -o dist/ --dry-run --json ```

`--dry-run` writes nothing. It returns a versioned `plan`: the effective configuration, every file selected or excluded and why, and the artifacts a real build would emit, each tagged `ship`, `retain-internal` or `optional`.

Read the artifact roles back to the user. The one that matters: a mapping file is tagged `retain-internal`, meaning it is the de-obfuscation key and must never be shipped or committed publicly.

## Step 3 — report

Give the user four things, in this order:

1. **Verdict.** Ready, ready with a named preset, or blocked by specific high-severity findings. 2. **What would break**, grouped by cause rather than by file: dynamic attribute access, `eval`/`exec`, framework reflection, model loading. Name the file and line for each; the user has to go look. 3. **The preset you would use** and why that one. If a framework was detected, say which signal detected it. 4. **What the build would emit**, from the dry-run plan, with the mapping's `retain-internal` role stated explicitly.

Quote the numbers from the JSON. Do not estimate, and do not soften a high-severity count into "a few issues".

## For CI

```bash pyobfus --check src/ --sarif pyobfus.sarif ```

SARIF 2.1.0 uploads to GitHub code scanning. Exit code is `1` when high-severity findings exist, which is the intended gate.

There is also a published GitHub Action that handles the exit-code trap correctly (findings and tool errors are separated, so `|| true` is not needed): `uses: zhurong2020/pyobfus-action@v1`.

## Honest limits of a review

- A clean `--check` does not promise the build will work. It means the known breakage patterns were not found. Verification happens in a real build, and that belongs to the pyobfus-protect skill. - Obfuscation is a deterrent against casual reading, not cryptographic security: the shipped code must still run, so anything it needs at runtime is present in what you hand over. Say that plainly if the user's expectation sounds higher. - Recent published work finds strong code models still reason over obfuscated source at close to their normal accuracy. Do not tell the user this makes their code unreadable to AI.

## Installing this skill

Copy it into whichever location your agent reads:

```bash # Claude Code mkdir -p ~/.claude/skills && cp -r skills/pyobfus-review ~/.claude/skills/

# Repository-scoped, picked up by agents that follow the .github/skills # convention (GitHub Copilot, Cursor, Codex CLI and others) mkdir -p .github/skills && cp -r skills/pyobfus-review .github/skills/ ```

Intended uses

  • Use Pyobfus Review when this documented workflow matches the task.

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.