getdev

free · open source · Apache-2.0

Verify, secure, and ship AI‑generated code.

AI coding agents hallucinate packages, hardcode secrets, skip auth, and leave debris behind. getdev is the toolbelt you run after the agent — one command for a trustworthy verdict on whether your code is real, safe, and shippable.

curl -fsSL https://getdev.ai/install.sh | sh

macOS · Linux · Windows — more ways to install below

one static binary · signed on every install channel · zero setup

getdev checkexample output

$ getdev check

Ship Score: 62/100

2 critical · 1 high · 3 medium · 2 low

CRITICAL  real/nonexistent-package   requirements.txt:4
  'requests-auth-helper' does not exist on PyPI
  → did you mean 'requests-oauthlib'?
CRITICAL  audit/hardcoded-secret     src/payments.ts:12
  Stripe live secret key assigned to 'stripeKey' (sk_live_…9f2a)
  → run: getdev env --write
HIGH      audit/missing-auth-middleware   src/routes/admin.ts:8
  '/admin/*' routes have no auth middleware in the chain
… 6 more findings · 2 fixable
$ 
  • No telemetry, ever
  • Runs locally
  • Deterministic core
  • Signed self-update
  • Never runs your code
  • Apache-2.0

the problem

Vibe code ships with the same defects, every time

real/nonexistent-package

Hallucinated packages

In published research, roughly one in five AI-generated code samples imports a package that does not exist. Attackers register those names — slopsquatting. getdev verifies every dependency against the real registries.

audit/hardcoded-secret

Leaked secrets

Agents paste live API keys straight into source. getdev finds them, moves them to .env, rewrites the references, and patches .gitignore — values are shown masked, never printed.

review/debug-leftover

Agent debris

Dead code, duplicate helpers, debug leftovers, orphaned files. getdev reads the diff the way a reviewer would and lists what the agent left behind.

quick start

Your first five minutes

  1. 01

    Install

    curl -fsSL https://getdev.ai/install.sh | sh

    One static binary, no runtime and no account. On Windows: irm https://getdev.ai/install.ps1 | iex — or use a package manager below.

  2. 02

    Set up your project

    getdev init

    Writes .getdev.toml and offers a pre-commit hook plus an agent-context block. Add --yes to accept sensible defaults without prompts.

  3. 03

    Get your Ship Score

    getdev check

    One deterministic 0–100 score with ranked, explainable findings across real, audit, review, and secrets — from a single scan pass.

  4. 04

    Fix the secrets

    getdev env --write

    Moves hardcoded secrets to .env, rewrites the references, and patches .gitignore. Values are shown masked and never printed.

  5. 05

    Checkpoint before big changes

    getdev snap -m "before refactor"

    Restore in one second with getdev back when the agent goes sideways. Checkpoints hide in git — your branches, history, and stash are untouched.

  6. 06

    Pre-flight for deploy

    getdev ship --write

    Generates a Dockerfile and a deploy checklist and validates your env. getdev never runs your code unless you explicitly pass --run-build.

In CI: getdev check --json --fail-on high — exit non-zero when anything at or above your threshold is found.

for AI coding agents

Built to run inside an AI coding loop

getdev is the verification step an agent can run on its own output. It is deterministic, keyless, and machine-readable — drop it into the edit → check → fix loop and gate on the exit code. If your agent installs and runs tools for you, point it at getdev.

  1. 1
    Generate or edit code

    your agent writes the change as usual

  2. 2
    getdev check --json --fail-on high

    one deterministic, machine-readable report over the whole change

  3. 3
    Parse findings, apply fixes

    stable JSON schema; each finding has a rule id, location, and remediation

  4. 4
    Re-run until exit code is 0

    gate the loop on the exit code, not on scraping stdout

Machine-readable output

--json emits the full findings report with a stable schema_version — parse it directly, no scraping.

Exit-code driven

0 clean · 1 findings at or above --fail-on · 2 execution error · 3 config error. Gate your loop on the code.

Deterministic & keyless

Same input → same output, no API key, no LLM calls in the core — agents get reproducible results every run.

Writes an agent-context block

getdev init drops a managed, marker-delimited block into your repo so the next agent session knows getdev is available and how to run it.

Safe in any sandbox

Runs locally, uploads nothing, and never executes your project code unless you pass ship --run-build.

Fast on real repos

One parse pass, checks in a couple of seconds on ~500 files — cheap enough to run on every iteration.

drop into your AGENTS.md / system prompt

After editing code, run `getdev check --json --fail-on high`.
Fix every finding at or above the threshold, then re-run until it exits 0.
Secrets: run `getdev env --write`. Checkpoint risky edits: `getdev snap` / `getdev back`.

machine-readable summary: getdev.ai/llms.txt

the toolbelt

Ten commands, one Ship Score

  • getdev check

    Run everything, get one Ship Score 0–100

  • getdev real

    Verify that packages, APIs, and model strings actually exist (anti-slopsquatting)

  • getdev audit

    Security scan tuned to AI-generated failure patterns

  • getdev review

    Diff analysis: dead code, duplicate helpers, debug leftovers

  • getdev env

    Extract hardcoded secrets to .env and rewrite the references

  • getdev snap / back

    One-command checkpoints and one-second restore (hidden in git underneath)

  • getdev ship

    Pre-flight: Dockerfile generation, env validation, deploy checklist

  • getdev init

    First-run setup: write .getdev.toml, offer a pre-commit hook and agent-context block

  • getdev update

    Signed self-update from GitHub Releases — SHA-256 checksum + cosign, atomic swap

  • getdev doctor

    Self-diagnostics: version, cache, registry reachability, config validity

how it works

Private and safe by design

Local-first, private

No telemetry, no analytics, no code upload — ever. The only network calls are the npm registry, PyPI, and GitHub Releases for self-update. Each is documented, enforced in CI, and disabled by --offline.

Deterministic core

No LLM calls anywhere in the core. Same input, same output, every run — no API key required. A future semantic layer is opt-in only, with your own key or a local model.

Safe by default

Commands never mutate files without explicit --write or --fix. Every mutation is atomic: write, reparse-verify, roll back on failure — with an automatic checkpoint taken first.

Never runs your code

Pure static analysis — tree-sitter ASTs, not execution. getdev only runs project code if you explicitly opt in with ship --run-build.

Rules are data

Detection rules are YAML, not code. Every rule ships with positive and negative test fixtures. Contributing a rule requires zero Rust.

Signed and verifiable

One Rust binary across macOS, Linux, and Windows. getdev update verifies a keyed-cosign signature over the release checksums against a key embedded in the binary — no network trust root.

The privacy promise is mechanically enforced, not just asserted: two CI gates fail the build if a second network client or an LLM SDK enters the tree, or if a network call appears outside the sanctioned registry and self-update paths. Full threat model on GitHub.

install

Pick your channel

Quick install

  • curl -fsSL https://getdev.ai/install.sh | sh

    macOS · Linux

  • irm https://getdev.ai/install.ps1 | iex

    Windows · PowerShell

Package managers

  • npm install -g getdev

    or: npx getdev

  • brew install getdev-ai/tap/getdev

    Homebrew

  • scoop install getdev

    Windows · Scoop

  • cargo install getdev

    or: cargo binstall getdev

Or grab a static binary for your platform from GitHub Releases.

already installed? getdev update — signed, checksum-verified

open source

Free forever, and yours to build on

The CLI is free — no accounts, no paid tiers, and that is stated policy, not a phase. Every released version is Apache-2.0 forever; anyone can fork the last commit. DCO sign-off, never a CLA, so contributed code can't be relicensed. The easiest first contribution needs zero Rust — detection rules are YAML data with test fixtures.

  • Add or improve a detection rule

    rules/*.yaml + fixtures

    no Rust
  • Report a false positive or bug

    issue templates

    no Rust
  • Improve the docs

    any .md file

    no Rust
  • Fix a bug, build a feature

    crates/ — good-first-issue labels

    Rust

Sponsor the work

Sponsorship pays for development time and cross-platform testing — it never buys features, priority rules, or influence over findings. The most valuable support right now is a star and a watch on the repo.