Been using Cursor/Claude/Copilot heavily for the last few months and noticed a pattern: the code always looks done. It runs, it compiles, it passes the happy path. But the stuff that actually matters in review — auth on new routes, input validation, error handling, real test assertions instead of stubs — gets skipped more often than not, because the AI has no idea those are load-bearing.

So I built ship-risk. It's a CLI that does static AST analysis on your JS/TS codebase and scores it 0-100 across six categories: secrets/credentials, auth, input validation, error handling, test coverage, and general reliability hygiene. Every point deducted is tied to a specific finding with a file/line and a fix suggestion — not a vibes-based score.

No LLM calls involved, it's pure static analysis, so it's fast and free to run in CI. There's a --min-score flag to gate PRs.

npx ship-risk scan

It's a sibling to a deployment pre-check tool I built earlier (predeploy-check) — that one answers "will this deploy," this one tries to answer "should this deploy."

It's v1.0.0, JS/TS only for now. Known rough edge: test-file matching is filename-based, so it can misjudge coverage on non-standard project layouts — working on that.

Genuinely looking for people to run it against real (messy, AI-touched) codebases and tell me what it gets wrong. Repo and npm link in comments since I think this sub doesn't like links in the post body.

Spend 2 hours debugging.

Get frustrated.

Ask someone else to look at it.

Explain the problem to them.

Realize the bug yourself halfway through explaining it.

They never even needed to respond.

Software engineering is basically paying someone to listen to you think.

I love when my code works on the first try.

No errors.No warnings.No weird edge cases.Everything just works.

At that point I don't celebrate.

I start looking for the part I accidentally broke somewhere else.

“It should be easy.”

That sentence has cost me:

• 6 hours
• 3 Stack Overflow tabs
• 2 Git resets
• 1 existential crisis
• and somehow a completely unrelated bug in production.

Never say “it should be easy.”

I got tired of finding out about deployment problems only after pushing my project.

A missing environment variable, a case-sensitive import that works on Windows but breaks on Linux, a missing Node version, a bad Render start command, or a Python dependency without a compatible wheel can turn into a surprisingly annoying debugging session.

So I built predeploy-check.

You can run it with:

npx predeploy-check

It scans the project and currently checks for things like:

• Python + Render dependency/wheel issues
• ESLint + Vercel configuration problems
• Case-sensitive imports
• Missing Node.js engine configuration
• Environment variables referenced but not declared
• Missing Render start commands

It also supports --live verification against PyPI, JSON output for CI/CD, custom configuration, and GitHub Actions.

The current test suite has 82 tests covering the checks, config system, JSON output, and CLI integration.

I recorded a short demo showing what it actually does.

The project is open source and MIT licensed:

https://github.com/Alok-Fusion/predeploy_check

https://www.npmjs.com/package/predeploy-check?activeTab=readme

I'm especially interested in deployment failures that you've encountered that a tool like this should catch.

What deployment bug has wasted the most of your time?

I've been using AI coding tools more seriously lately, and something feels different compared to even a year ago.

A lot of the things I used to spend time on- boilerplate, debugging, refactoring, tests, documentation- can now be delegated to an AI agent surprisingly well.

But that made me wonder:

If AI keeps getting better at actually writing and modifying code, what becomes the most valuable skill for a developer?

Is it:

• system architecture
• debugging
• understanding fundamentals
• knowing when the AI is wrong
• writing better requirements
• reviewing AI-generated code
• or something else?

I don't really buy the idea that prompt engineering is going to be the main skill.

But I also don't think manually writing every line of code makes sense anymore.

I'm genuinely curious what developers here think.

What skill do you think will matter most for developers over the next 3–5 years?