Skip to content
Back to search

appsec-audit

MarketplaceWorks with Claude CodeGitHub

Security audit skill for web and mobile app codebases.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/savicsly--app-security-audit/badge.svg)](/listings/savicsly--app-security-audit)

HTML

<a href="/listings/savicsly--app-security-audit"><img src="/api/listings/savicsly--app-security-audit/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Pick one method. All of them install the same skill.

Option 1: Skills CLI (any tool that supports Agent Skills)

Run this inside your project folder:

npx skills add savicsly/app-security-audit

The full GitHub URL works too:

npx skills add https://github.com/savicsly/app-security-audit

The [Skills CLI](https://github.com/vercel-labs/skills) asks which tools to install for (Claude Code, Cursor, Codex, Copilot and others) and whether to install for this project or globally. Add `-g` for all your projects, or `-a claude-code` to pick a tool without the prompt. The package is called `skills`, plural; `npx skill add` will not work.

Option 2: Bundled installer (npx)

npx app-security-audit                       # from npm
npx github:savicsly/app-security-audit       # straight from GitHub, no npm needed

It asks which tool you use and where to install. Or skip the questions:

npx app-security-audit install --agent cursor            # this project, Cursor
npx app-security-audit install --agent vscode            # this project, VS Code (GitHub Copilot)
npx app-security-audit install --agent claude --global   # all your projects, Claude Code
npx app-security-audit install --all --yes               # every supported tool

| Tool | `--agent` | This project | All projects (`--global`) | |---|---|---|---| | Claude Code | `claude` | `.claude/skills/` | `~/.claude/skills/` | | Cursor | `cursor` | `.cursor/skills/` | `~/.cursor/skills/` | | VS Code (GitHub Copilot) | `vscode` | `.github/skills/` | `~/.copilot/skills/` | | OpenAI Codex | `codex` | `.codex/skills/` | `~/.codex/skills/` | | Gemini CLI | `gemini` | `.gemini/skills/` | `~/.gemini/skills/` | | Windsurf | `windsurf` | `.windsurf/skills/` | `~/.codeium/windsurf/skills/` | | OpenCode | `opencode` | `.opencode/skills/` | `~/.config/opencode/skills/` | | Shared folder read by several tools | `agents` | `.agents/skills/` | `~/.agents/skills/` |

For any other tool, point the installer at its skills folder: `npx app-security-audit install --dir path/to/skills`.

Other commands: `status` shows where the skill is installed, `uninstall --agent <name>` removes it, and running `install` again updates it (use `npx app-security-audit@latest` to be sure you get the newest version).

The installer only copies files. It has no dependencies, makes no network requests, and collects nothing.

Option 3: Claude Code plugin

Inside Claude Code:

/plugin marketplace add savicsly/app-security-audit
/plugin install app-security-audit@appsec-audit

Updates then arrive through `/plugin`.

Option 4: Manual

Copy the `skills/app-security-audit` folder from this repository into your tool's skills folder (see the table above).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines
  1. {
  2. "name": "appsec-audit",
  3. "owner": {
  4. "name": "Victor Bala"
  5. },
  6. "description": "Security audit skill for web and mobile app codebases.",
  7. "plugins": [
  8. {
  9. "name": "app-security-audit",
  10. "source": ".",
  11. "description": "Audits web and mobile app code against the OWASP Top 10:2025, writes a professional report, and fixes what you approve.",
  12. "category": "security"
  13. }
  14. ]
  15. }
README.md · README · 194 lines
  1. # App Security Audit
  2. [![npm](https://img.shields.io/npm/v/app-security-audit)](https://www.npmjs.com/package/app-security-audit)
  3. An AI agent skill that audits a web or mobile app's source code for security weaknesses, writes a professional report mapped to the OWASP Top 10:2025, and fixes the problems you approve.
  4. It was built for apps made quickly, often with AI coding tools, where security was not part of the process. It works in Claude Code, Cursor, VS Code with GitHub Copilot, OpenAI Codex, Gemini CLI, Windsurf, OpenCode, and any other tool that supports the open Agent Skills format.
  5. ## Install
  6. Pick one method. All of them install the same skill.
  7. ### Option 1: Skills CLI (any tool that supports Agent Skills)
  8. Run this inside your project folder:
  9. ```bash
  10. npx skills add savicsly/app-security-audit
  11. ```
  12. The full GitHub URL works too:
  13. ```bash
  14. npx skills add https://github.com/savicsly/app-security-audit
  15. ```
  16. The [Skills CLI](https://github.com/vercel-labs/skills) asks which tools to install for (Claude Code, Cursor, Codex, Copilot and others) and whether to install for this project or globally. Add `-g` for all your projects, or `-a claude-code` to pick a tool without the prompt. The package is called `skills`, plural; `npx skill add` will not work.
  17. ### Option 2: Bundled installer (npx)
  18. ```bash
  19. npx app-security-audit # from npm
  20. npx github:savicsly/app-security-audit # straight from GitHub, no npm needed
  21. ```
  22. It asks which tool you use and where to install. Or skip the questions:
  23. ```bash
  24. npx app-security-audit install --agent cursor # this project, Cursor
  25. npx app-security-audit install --agent vscode # this project, VS Code (GitHub Copilot)
  26. npx app-security-audit install --agent claude --global # all your projects, Claude Code
  27. npx app-security-audit install --all --yes # every supported tool
  28. ```
  29. | Tool | `--agent` | This project | All projects (`--global`) |
  30. |---|---|---|---|
  31. | Claude Code | `claude` | `.claude/skills/` | `~/.claude/skills/` |
  32. | Cursor | `cursor` | `.cursor/skills/` | `~/.cursor/skills/` |
  33. | VS Code (GitHub Copilot) | `vscode` | `.github/skills/` | `~/.copilot/skills/` |
  34. | OpenAI Codex | `codex` | `.codex/skills/` | `~/.codex/skills/` |
  35. | Gemini CLI | `gemini` | `.gemini/skills/` | `~/.gemini/skills/` |
  36. | Windsurf | `windsurf` | `.windsurf/skills/` | `~/.codeium/windsurf/skills/` |
  37. | OpenCode | `opencode` | `.opencode/skills/` | `~/.config/opencode/skills/` |
  38. | Shared folder read by several tools | `agents` | `.agents/skills/` | `~/.agents/skills/` |
  39. For any other tool, point the installer at its skills folder: `npx app-security-audit install --dir path/to/skills`.
  40. Other commands: `status` shows where the skill is installed, `uninstall --agent <name>` removes it, and running `install` again updates it (use `npx app-security-audit@latest` to be sure you get the newest version).
  41. The installer only copies files. It has no dependencies, makes no network requests, and collects nothing.
  42. ### Option 3: Claude Code plugin
  43. Inside Claude Code:
  44. ```
  45. /plugin marketplace add savicsly/app-security-audit
  46. /plugin install app-security-audit@appsec-audit
  47. ```
  48. Updates then arrive through `/plugin`.
  49. ### Option 4: Manual
  50. Copy the `skills/app-security-audit` folder from this repository into your tool's skills folder (see the table above).
  51. ## Use
  52. Restart or reload your tool after installing, open the app you want to check, and ask in plain words:
  53. - "Run a security audit on this app."
  54. - "Is my app safe to launch? Check it against the OWASP Top 10."
  55. - "Find and fix the security holes in this codebase."
  56. In Claude Code with the plugin installed you can also type `/app-security-audit:app-security-audit`.
  57. Before scanning, the assistant checks for the optional scanners (Gitleaks, Semgrep, OSV-Scanner and others, depending on your stack). It tells you which are missing, what each would catch and how to install it, and asks whether to install them or continue without them. Any scan that did not run is listed in the report with its install command.
  58. You will get `.security-audit/security-audit-report.md`. That folder is added to `.git/info/exclude` so the report is never committed: it describes exploitable weaknesses and must stay out of your repository. The exclusion applies only to your local copy, so add `.security-audit/` to `.gitignore` if your team runs audits too. Then tell the assistant which findings to fix. Nothing in your code is changed until you have seen the report and chosen.
  59. For the best results:
  60. - Open the whole repository, including backend code, database migrations and rules files.
  61. - If you use Supabase or Firebase and your rules exist only in the dashboard, export them when asked. Those rules are your main protection and cannot be reviewed otherwise.
  62. - Keep the git history if possible, so secrets committed in the past can be found.
  63. - Use a capable model. The manual review depends on the model's reasoning, so results vary between tools and models.
  64. ## What it does
  65. 1. **Identifies your app.** Detects the languages, frameworks and services in the codebase.
  66. 2. **Maps the attack surface.** Lists every route, endpoint and entry point, and what data sits behind them.
  67. 3. **Runs automated checks.** A bundled pattern scan, plus dependency, secret and static analysis tools when they are available.
  68. 4. **Reviews the code manually.** Works through each security category against your code, concentrating on the flaws scanners cannot see, such as missing permission checks.
  69. 5. **Writes a report.** Plain-language summary for the owner; exact locations, evidence and corrected code for the developer.
  70. 6. **Fixes what you approve.** Applies minimal patches, re-checks them, and updates the report.
  71. ## Stacks covered
  72. **Full coverage** means the skill has a dedicated checklist for that technology: its specific pitfalls, its configuration files, and fixes written in its idiom.
  73. | Area | Full coverage |
  74. |---|---|
  75. | Web frontends and full-stack frameworks | Next.js, React (Vite, Create React App), Vue, Nuxt, Svelte, SvelteKit |
  76. | Node.js backends | Express, NestJS, Fastify |
  77. | Python backends | Django (including Django REST Framework), Flask, FastAPI |
  78. | PHP | Laravel |
  79. | Ruby | Ruby on Rails |
  80. | Backend-as-a-service | Supabase (row level security, storage, edge functions), Firebase (Firestore, Realtime Database and Storage rules, Cloud Functions) |
  81. | Cross-platform mobile | React Native, Expo, Flutter |
  82. | Native mobile | Android (Kotlin, Java), iOS (Swift) |
  83. | Data and auth libraries | Prisma, Drizzle, Mongoose, Sequelize, TypeORM, SQLAlchemy; NextAuth/Auth.js, Clerk, Auth0, Supabase Auth, Firebase Auth, custom JWT |
  84. | Delivery and infrastructure files | Dockerfile, Docker Compose, GitHub Actions and other CI, Terraform, Kubernetes manifests, hosting config |
  85. **Generic coverage** means the skill audits with a framework-agnostic checklist. It will still find many problems, with less depth than a fully covered stack, and the report says so.
  86. | Generic coverage |
  87. |---|
  88. | Go, Java and Spring Boot, .NET and ASP.NET Core, Angular, Remix, Astro, Koa, Hono, plain PHP, plain Node.js or Python without a recognized framework, Rust, Elixir/Phoenix, and anything else |
  89. The skill tells you which tier applies to your project before it starts the review.
  90. **Not covered:** desktop applications, games, embedded firmware, smart contracts, and network or cloud-account penetration testing.
  91. ## Security standards applied
  92. | Standard | Used for |
  93. |---|---|
  94. | OWASP Top 10:2025 | Every audit; the backbone of the report |
  95. | OWASP API Security Top 10 (2023) | Apps with an API |
  96. | OWASP Mobile Top 10 (2024) | Mobile apps |
  97. | OWASP Top 10 for LLM Applications (2025) | Apps that call an AI model |
  98. | OWASP ASVS 5.0 and MASVS | Deeper verification on request |
  99. | CWE | Classifying each finding |
  100. | CVSS | Optional scoring on request |
  101. ## What the report contains
  102. - Executive summary with an overall risk rating and the top problems in plain language
  103. - Scope, stack detected, coverage tier, and tools run
  104. - Findings table, then each finding in detail: severity, confidence, OWASP category, location, evidence, impact, fix with code, and how to verify the fix
  105. - OWASP Top 10:2025 coverage matrix showing what was examined in every category
  106. - What the app already does well
  107. - A prioritized remediation roadmap
  108. - Limitations: what was not reviewed
  109. ## Limits you should know
  110. - **It reviews code; it does not attack your running app.** Problems that only appear at runtime, or in infrastructure outside the repository, may not be found.
  111. - **It reduces risk; it cannot prove an app is secure.** No audit can, automated or human.
  112. - **It is not a compliance certification** (PCI DSS, SOC 2, ISO 27001, HIPAA, GDPR, NDPA), though findings can inform that work.
  113. - **Some fixes need you.** Leaked keys must be rotated at the provider, and dashboard settings must be changed by the account owner. The report lists these separately.
  114. - **Review changes before deploying them.** Test fixes as you would any other code change.
  115. - For apps handling payments, health records, or large volumes of personal data, also commission an independent penetration test before launch.
  116. Only use this skill on code you own or are authorized to assess.
  117. ## Requirements
  118. - Node.js 18 or later, for the `npx` installers only
  119. - Python 3, for the bundled scanner scripts (standard library only). Without it the audit still runs, minus the pattern scan.
  120. - Optional tools that improve coverage when installed: Semgrep, Gitleaks, OSV-Scanner, and the audit command for your package manager (`npm audit`, `pip-audit`, `composer audit`, `bundle audit`)
  121. ## Repository layout
  122. ```
  123. app-security-audit/
  124. ├── bin/cli.js npx installer
  125. ├── package.json
  126. ├── .claude-plugin/
  127. │ ├── plugin.json Claude Code plugin manifest
  128. │ ├── marketplace.json Lets Claude Code install from this repository
  129. │ └── icon.png
  130. └── skills/app-security-audit/
  131. ├── SKILL.md Workflow the assistant follows
  132. ├── scripts/
  133. │ ├── detect_stack.py Identifies the stack and coverage tier
  134. │ └── pattern_scan.py Sweep for secrets and risky patterns (values masked)
  135. ├── references/ OWASP lists, per-stack checklists, tooling, report guidance
  136. └── assets/report-template.md
  137. ```
  138. ## License
  139. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.