Map the assets and trust boundaries

List sensitive data, privileged operations, external integrations, and actors with different permissions. Trace a request from an untrusted caller to each protected operation. The important question is not whether a route includes a login check, but whether it authorizes the specific requested resource.

Illustrative scenario: a generated invoice endpoint requires authentication but loads invoices by a caller-supplied identifier without checking account ownership. Test two separate accounts. This reveals an object authorization failure even when both requests use valid sessions and the page looks correct.

Inspect generated shortcuts with high impact

Review raw database queries, shell execution, uploaded files, template rendering, and outbound URL fetches. Identify where untrusted values enter those operations. Also inspect default credentials, permissive cross-origin settings, debug endpoints, and secrets placed in client-visible configuration or logs during prototype development.

Dependency risks require a separate inventory. Confirm package identity, purpose, installed version, and relevant advisories. A package being suggested by an assistant is not evidence of legitimacy. Check transitive dependencies and deployment configuration rather than reviewing only newly generated application source files.

Turn risks into targeted verification

For each important boundary, write an abuse case and the expected rejection. Examples include another user's identifier, oversized uploads, expired credentials, and malformed input. Use security scanners as one source of findings, then validate whether the reported path exists and is reachable in your application.

Record residual risk and assign an owner for each unresolved finding. Prioritize exploitable paths with material impact rather than the longest scanner report. This overview supports risk discovery; use a separate remediation plan to specify code changes, regression checks, and rollout decisions for the application.

Working sheet

Risk categories to inspect
RiskIllustrative failureVerification
AuthorizationUser reads another account's invoiceCross-account request
InjectionInput becomes executable query textReview data-to-query path
Secrets exposureServer token bundled into frontendInspect built assets
Unsafe dependencyUnverified package added for convenienceCheck registry identity and advisories
Download this worksheet (CSV)

Read security studies with their limits

A study measures a particular set of tasks, models and checking methods. Record those details before applying its findings to a different application. Do not treat a percentage from one benchmark as your repository’s vulnerability rate.

For your own code, reproduce the threatened behaviour with a safe local fixture and record which control prevents it. Link claims about study outcomes to the original paper, not a vendor summary.

Questions about security risks in AI-generated code

Are AI applications automatically insecure?

No. Security depends on architecture, implementation, deployment, and verification. Generated code still needs those controls.

Does a clean scan prove the application is secure?

No. Automated scans have limited context and coverage, especially for business authorization and workflow abuse.

How should I use the working sheet?

Download the CSV and replace the sample rows with evidence from your repository. Record a clear acceptance check and an owner for each item. Keep unresolved assumptions visible rather than treating the example as a completed assessment.

Sources and further reading

Examples are illustrative. They are not customer results, security guarantees, or a substitute for checking the documentation for your installed version.

Make the next change verifiable.

Getzilla is an open source workflow for changes to existing repositories. Inspect the project, define acceptance checks, and keep independent review in the loop.

See the repository workflow See current access and pricing