Skip to main content
skill CX Codex

forge-app-review — Claude Code skill: what it does, how to install

forge-app-review — a skill for Claude Code conducts pre-release readiness checks on Atlassian Forge apps. Runs when reviewing manifest wiring, architecture, or overall deploy posture.

Apache-2.0 542 installs ★ 33 updated 2026-10-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add atlassian/forge-skills --skill forge-app-review -a claude-code
Open on GitHub

What forge-app-review does

The skill audits Atlassian Forge apps prior to deployment without editing workspace files. It verifies that entries in manifest.yml align with package.json, checking module references, function paths, and runtime settings. Resolver definitions are verified against frontend calls across UI Kit or Custom UI entry points.

Inspection covers missing egress declarations, unneeded scopes, unauthenticated web triggers, and plain-text tokens. Whenever an app imports @forge/teamwork-graph or specifies graph:connector, the review incorporates connector-specific module guidelines.

Deep SAST assessments, execution-cost modeling, and live error debugging are intentionally excluded, deferring those problems to forge-security-review, forge-cost-optimizer, or forge-debugger.

What it helps with

  • find missing resource paths or broken handler bindings in manifest.yml
  • detect mismatched resolver names between backend exports and UI invokes
  • catch missing API scopes or undeclared egress domains prior to shipping
  • spot unauthenticated web triggers and hardcoded secret strings

Example prompts for the agent

  • Review my Forge app for release readiness
  • Run a pre-deploy check on this Forge manifest
  • Perform a general app review before I ship to production

How to install forge-app-review

1Skills CLI (Vercel)

npx skills add atlassian/forge-skills --skill forge-app-review -a claude-code

2Manually: put the files in place

~/.claude/skills/forge-app-review/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/forge-app-review/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about forge-app-review

How to install forge-app-review in Claude Code?

Run npx skills add atlassian/forge-skills --skill forge-app-review -a claude-code. The skill file is placed in ~/.claude/skills/forge-app-review/SKILL.md.

What does forge-app-review do?

It scans manifest declarations, scripts, packages, resolver wiring, and basic security signals to produce a prioritized table of release blockers.

Does forge-app-review replace deep security audits?

No. For full SAST, authorization verification, and tenant isolation reviews, it explicitly delegates to forge-security-review.

Source text

SKILL.md · Apache-2.0
---
name: forge-app-review
description: >
  Performs a lightweight pre-release readiness review of Atlassian Forge apps across manifest/module wiring,
  architecture, runtime compatibility, dependency posture, tests, deploy readiness, and obvious security,
  cost, or reliability smells. Use when the user asks "review my Forge app", "pre-deploy check",
  "is this app ready to ship", "review manifest", "general app review", "release readiness", or asks for a
  broad quality pass. Do not use for deep security audits/SAST/exploitability review, cost optimization,
  or diagnosing a known broken app; route those to forge-security-review, forge-cost-optimizer, or
  forge-debugger respectively.
---

# Forge App Review

Run a general Forge release-readiness review. This skill is the front door for broad app review, not a replacement for specialist security, cost, or debugging skills.

## Boundaries

Use this skill for:

- Pre-deploy and release-readiness checks.
- General architecture and maintainability review.
- Manifest/module/resource/function wiring.
- Runtime, dependency, package, and script sanity checks.
- Basic tests/deploy readiness and operational hygiene.
- Obvious security, cost, or reliability smells that should trigger a deeper specialist pass.

Use another skill instead when the user's primary intent is:

- Deep security audit, SAST, authz, secrets, tenant isolation, exploitability, or CVSS reporting -> `forge-security-review`.
- Cost optimization, invocations, GB-seconds, storage/log volume, trigger frequency, or memory tuning -> `forge-cost-optimizer`.
- A known failure, error message, blank UI, failed deploy/install, broken resolver, missing app, or logs/tunnel diagnosis -> `forge-debugger`.

If a broad review finds a deep security/cost/debug concern, include it as a handoff recommendation rather than duplicating the specialist workflow.

## Review Rules

- Audit first. Do not modify app files unless the user explicitly asks to apply fixes.
- Read the codebase before making claims.
- Prefer concrete file/line evidence.
- Keep findings focused on bugs, release blockers, meaningful risks, and missing validation.
- Do not run full SAST or cost tooling from this skill. Recommend the specialist skill when warranted.
- Do not report speculative security or cost observations as confirmed vulnerabilities or savings.

## Module & Capability Routing
Detect modules declared in `manifest.yml` or package dependencies, and load specific review guides:

- **Teamwork Graph / Forge Connectors:**
  - If the app declares `graph:connector`, `teamwork-graph-connector`, or imports `@forge/teamwork-graph`:
  - 👉 **Follow and evaluate against [`./modules/connector-review.md`](./modules/connector-review.md)**.

---

## Workflow

1. Read `manifest.yml` or `manifest.yaml`.
   - Identify modules, resources, functions, resolver bindings, triggers, web triggers, remotes, permissions, runtime, and memory settings.
   - Verify referenced handlers/resources exist.
2. Read `package.json`.
   - Check Forge package fit, scripts, runtime assumptions, direct dependencies, and obvious unused/missing packages.
3. Inspect source files.
   - Backend/resolvers: `resolver.define`, handler exports, product API calls, storage usage, external fetches, logging, error handling.
   - Frontend: UI Kit or Custom UI resource entry points, `invoke()` patterns, bridge usage, loading/error states.
4. Inspect tests and project docs when present.
   - Note missing tests only when behavior risk justifies it.
5. Produce a prioritized readiness report.

## What To Check

### Release Blockers

- Manifest references a missing handler, resource path, or module key.
- Resolver names called by the frontend do not match `resolver.define()` names.
- Required scopes or egress permissions are missing for actual API/fetch usage.
- Runtime, package versions, or module syntax likely fail `forge lint`, build, deploy, or install.
- App has no clear way to exercise its primary user flow.

### Architecture And Maintainability

- Module type matches the intended UX surface.
- Resolver boundaries are coherent and not overly monolithic for the app size.
- Sensitive or privileged logic stays backend-side.
- UI-only formatting/transforms are not unnecessarily forced through backend functions.
- Error handling is sufficient for user-facing workflows.
- Code organization matches existing project style.

### Lightweight Security Signals

Only flag obvious signals and recommend `forge-security-review` for deep validation:

- Broad/write/admin scopes without visible usage.
- `api.asApp()` in user-triggered resolvers without obvious authorization checks.
- Hardcoded credentials or token-like literals.
- External fetches without manifest egress entries.
- Web triggers without visible authentication strategy.
- Full payload/request logging that may expose user, tenant, or secret data.

### Lightweight Cost Signals

Only flag obvious signals and recommend `forge-cost-optimizer` for deep analysis:

- Resolver invoked only to return static data or product context.
- Multiple independent `invoke()` calls on page load.
- Scheduled triggers that look like broad polling.
- Product triggers without filters or `ignoreSelf` where applicable.
- Full payload/API response logging in hot paths.
- Storage writes on every invocation.

### Lightweight Debuggability Signals

Only flag readiness gaps; use `forge-debugger` when there is an observed failure:

- Missing loading/error states around async UI paths.
- Logs are either too noisy or absent around important failures.
- README or scripts do not explain how to lint/build/deploy/test.
- App has no obvious local verification command besides `forge lint`.

## Output Format

Return a concise Markdown report. **Findings must be a table** (not a numbered list). Include a **Source** column for every finding so the reader knows which review guide or area produced it.

**Source values** (use the most specific that applies — Source is the **checklist/module or review area**, not merely the file type):

- `manifest` — general Forge manifest wiring, scopes, egress, or module keys **not** covered by a module-specific guide
- `resolver` — backend/resolver wiring and runtime behavior
- `frontend` — UI Kit / Custom UI invoke and bridge patterns
- `dependencies` — `package.json` / runtime package fit
- `tests` — missing or inadequate verification
- `general` — cross-cutting readiness hygiene not covered above
- Module-specific labels — when a module review guide is loaded (under `./modules/`), use the Source label that guide defines (for example `connector`). Do **not** re-label those findings as `manifest` just because evidence lives in `manifest.yml`.

**Location rules** (do not path-only):

- Always cite precise `path:line` or `path:start-end` (multiple citations OK).
- Include the contributing code excerpt in the Location cell — the exact lines that produced the signal, not just the filename.
- Because Markdown table cells cannot nest ` ``` ` fences reliably, wrap the excerpt in HTML: `<pre><code>...</code></pre>`.
- Keep excerpts tight (typically ≤15 lines). For absences (e.g. a missing required block), show the nearest enclosing stanza and note what is missing in Description.

```markdown
# Forge App Review Results

## Summary
- Readiness: Ready | Needs changes | Blocked
- Highest-risk area: <manifest | resolver wiring | permissions | dependencies | tests | operational hygiene | module-specific>
- Files inspected: <short list>
- Specialist handoffs: <none | security | cost | debugger>

## Findings

| Severity | Source | Finding | Location | Description | Doc | Fix |
|----------|--------|---------|----------|-------------|---------|-----|
| Critical \| Warning \| Info | <source> | <short title> | `path:start-end`<br><pre><code>…excerpt…</code></pre> | <why this matters / observed pattern> | <DAC or checklist anchor title + URL> | <specific remediation> |

Sort rows Critical → Warning → Info. Omit the Doc column cell only when no public/doc anchor applies; keep the column.

## Clean Areas
- <important categories checked with no issues>

## Suggested Next Step
- <apply fixes | run specialist review | deploy/lint/test command>
```

If there are no findings, say the app looks ready from this general review and list any residual specialist reviews that were intentionally out of scope.

© atlassian · Apache-2.0 · atlassian/forge-skills

Similar skills

All skills for Code review and refactoring →

From the same set8

forge-app-builder forge-app-builder — a skill for Claude Code and Codex that scaffolds, builds, and updates Atlassian Forge apps. Activates when editing manifests, UI Kit, Custom UI, or backend functions. CX Codex +1 552installs forge-debugger forge-debugger — a Claude Code skill that diagnoses and fixes issues in Atlassian Forge apps. It kicks in for failed deploys, blank interfaces, resolver errors, and permission problems. CX Codex +1 533installs forge-connector forge-connector — a Claude Code skill for building Atlassian Forge Teamwork Graph connector apps that ingest external data into Rovo Search. CX Codex +1 453installs forge-security-review The forge-security-review skill for Claude Code reviews Atlassian Forge apps against code and Forge-specific security rules. It activates for security audits, authorization checks, and tenant isolation reviews. CX Codex +1 442installs forge-cost-optimizer The forge-cost-optimizer Claude Code skill audits Atlassian Forge apps for avoidable platform usage. It examines function calls, API requests, storage activity, and trigger schedules. CX Codex +1 418installs forge-onboarding Skill for Claude Code and Codex guides first-time builders through scaffolding and deploying a Forge Guru Rovo agent. Activates on initial Forge onboarding. CX Codex +1 173installs forge-skills Bundles Forge-focused skills and MCP tooling. It scaffolds apps, reviews them pre-deploy, debugs production issues, and keeps the agent current on Forge APIs. ★ 33repo stars

More in the catalog

Project sponsors

Companies that keep this analytics open