> ## Documentation Index > Fetch the complete documentation index at: https://docs.neo.projectdiscovery.io/llms.txt > Use this file to discover all available pages before exploring further. # SAST: Static Code Analysis Static analysis tools scan source code against a library of patterns and flag anything that looks like a known bad practice. That produces a lot of alerts, most of which aren't reachable or exploitable in your actual application. Someone still has to read every finding and decide what's real, which is why most SAST backlogs grow faster than they shrink. Running a dedicated SAST product on top of that means a separate license, a separate rule set to tune, and a separate review queue to maintain, on top of whatever else your security team is already doing. ## How Neo Solves This 1. **Reads the source directly.** Neo reads your repository the way a security engineer would: mapping the architecture and tracing data flow end to end, not just matching patterns against a rule set. 2. **Runs static analysis as one input, not the whole picture.** Neo's sandbox comes with Semgrep and the rest of its static analysis tooling pre-installed, so a static pass happens automatically as part of any code-aware task. What it finds feeds into the same reasoning layer as everything else Neo does. 3. **Only reports what's actionable.** A pattern match by itself isn't a finding. Neo traces whether the flagged code path is actually reachable and exploitable in your application before it surfaces anything, so the queue you get is what you should fix, not everything a rule set matched. 4. **Works from findings you already have.** If you already run Semgrep, Snyk, or another scanner, you don't need to give that up or buy Neo a license to read it. Paste or attach the scanner output on the [Vuln triage](/essentials/vuln-triage) workflow and Neo validates each finding against your codebase, ranking real exploitability over raw scanner severity. 5. **Hands off to dynamic testing.** A static finding tells Neo where a vulnerability might be reachable in the code. When there's also a running instance to test against, Neo takes that lead and confirms it dynamically instead of stopping at "this looks reachable", the same testing [DAST](/use-cases/dast) runs on its own. Static and dynamic findings go through the same verification, so a finding from one can be checked by the other. ## What This Looks Like in Practice You point Neo at a repository: ``` Run a static code audit of https://github.com/org/repo. Focus on authentication and payment processing. ``` Neo reads the codebase and flags a spot where a session token is compared with `==` instead of a constant-time comparison. Rather than stopping there, it traces the code path to confirm the comparison is reachable from an unauthenticated endpoint, and reports it with the exact file, line, and a working proof of the timing difference, instead of listing every `==` in the codebase the way a pattern-matching scanner would. ## What You Get * **Findings validated, not just matched.** Every flagged issue is checked for reachability and exploitability before it's reported. * **Your existing scanner output still counts.** Import findings from Semgrep, Snyk, or any other tool and Neo triages them against your actual codebase instead of asking you to trust the raw severity label. * **A running start for dynamic testing.** A static finding hands off to [DAST](/use-cases/dast) testing against a live environment when one is available, so "reachable in code" gets confirmed exploitable instead of staying theoretical. ## Setup To run a SAST-style audit: 1. Connect your repository in **Settings → Applications → [GitHub](/integrations/github)**, or paste the repository URL directly into a task. 2. Click **Code audit** from the Neo home screen, or start a conversation and describe what to review. 3. To bring in findings from an existing scanner, use the [paste-or-attach workflow](/essentials/vuln-triage#paste-or-attach-a-report) on the Vuln triage form. The complementary half: full vulnerability testing against the running application. The workflow that runs a SAST-style pass end to end.