CodeScout AI

AI-Powered Automated Code Review

Finds the real mistakes in your code in about a second: typos, undefined names, wrong imports, wrong function calls, broken syntax and security holes. Then an AI agent explains them, fixes them and re-runs your tests to check each fix.

💡 Inspiration

Every developer knows the moment: you run the project and it crashes because of one misspelled name, one import that points to a file that does not exist, or one missing bracket. These small mistakes cost hours, and they are easy to miss even in a careful review.

Linters catch only a fixed set of patterns. AI assistants are flexible, but they can invent problems, miss real ones, and give no way to tell which is which. We wanted a reviewer you can trust for the things a machine can be certain about, and an assistant for the rest, one that tells you not only what is wrong, but why, and how to fix it.

🚀 What it does

CodeScout AI reviews a whole project with two layers.

1. Strict review (no AI model, works offline). Every file is checked with real parsers and fixed rules. Each finding gives the exact line and column, the offending code with a marker, a "did you mean...?" suggestion and how to fix it.

  • Syntax: missing colons, unclosed or extra brackets, misspelled keywords, bad indentation, broken JSX, invalid JSON, YAML and HTML.
  • Typos and undefined names: itmes → "did you mean items?", self.nmae, os.pth, useSate, <Hedaer />.
  • Wrong imports: a name or module that does not exist in the project, import X from './Hedaer', a name a module does not export, a package missing from package.json.
  • Wrong calls across files: too many or missing arguments, misspelled keyword arguments.
  • Bug patterns and security: x / 0, assert (cond, "msg"), mutable default arguments, SQL injection, shell=True, hard-coded secrets and tokens.

The page also states what was analysed and what static analysis cannot see, so a clean result can be trusted for exactly what it covers.

2. AI agent (when a model key is connected). It explains the code with citations, traces the root cause of an error, writes a targeted fix, and runs your tests before and after to check that the fix works. Nothing is applied to your project without your approval.

Understand any project: a system map of folders with labelled arrows, an execution-flow view (sequence diagram and flowchart) showing what a route calls across files, a file-structure view, and a 3D map of the whole code base. Review code from the web app, paste code for an instant check, or run it from the command line or CI (python -m app.review . --fail-on high, with SARIF export for GitHub code scanning).

🛠️ How we built it

  • Review engine: our own, in Python. For Python files it uses Python's compiler and a scope-aware analyser (names, attributes, imports, call arguments). For JavaScript, TypeScript, JSX and five other languages it uses Tree-sitter grammars. JSON, YAML, TOML, HTML and CSS have their own validators.
  • Backend: Python and FastAPI.
  • AI agent: LangGraph with Gemini or OpenAI behind one interface and an offline mode, hybrid retrieval over the code (vectors, keyword search and reranking), and a sandbox for running tests.
  • Code intelligence: import, call and inheritance graphs that connect findings across files.
  • Frontend: Next.js, React, TypeScript, Tailwind CSS, React Flow and React Three Fiber (3D).
  • Deployment: backend on Render, frontend on Vercel.

📊 Results (measured, reproducible)

  • 54 of 54 hand-written seeded mistakes found (Python, JavaScript/React, JSON, HTML, YAML, CSS), 53 on exactly the right line.
  • 0 false alarms at high or medium severity on 6 known-good programs.
  • On an untouched real open-source Flask project (52 files), 0 high-severity findings. With six mistakes planted, all six were found in under 100 ms.
  • On our own 130-file backend: 0 high-severity findings, in about 1.7 seconds.

These cases were written by us and are a yardstick for this engine, not a comparison with other tools. We have not measured the quality of the AI agent's fixes.

⚡ Challenges we ran into

  • False alarms. Running the review on our own working code exposed real ones: JSX text containing &, a safe database query API flagged as SQL injection, a URL constant named TOKEN_URL flagged as a secret, nested functions mistaken for methods. We fixed each one and made "no false alarms on working code" part of the benchmark.
  • Precise locations. Parsers report a broken function as one big error. We had to find the innermost error so the marker lands on the real line.
  • Multi-file understanding. Checking imports and call arguments across files without guessing, and skipping dynamic code instead of making things up.
  • Honest verification. A fix is only marked as verified if the tests actually ran, never on the AI's say-so.
  • Real-browser bugs. Testing in a real browser exposed page errors that automated tests missed, which we fixed.

🏆 Accomplishments that we're proud of

  • A reviewer that is exact about what it reports and honest about what it cannot see.
  • One workflow from detection, to explanation, to fix, to test verification.
  • Fast (about a second), offline, and usable from the web app, the command line and CI.

📚 What we learned

  • Deterministic analysis gives concrete evidence, and AI helps with context and fixes. They work best together.
  • Measuring false alarms on real, working code matters as much as measuring what you catch.
  • Repository-level understanding finds bugs that single-file checks cannot.

🔮 What's next

  • Deeper analysis for JavaScript, TypeScript, Java, Go and Rust (today Python is deepest, and Java, Go, Rust, C and C++ get syntax checks only).
  • Type checking and more security rules.
  • Measuring the AI agent's fix quality with a real model.
  • Automatic review comments on every pull request.

Our vision: a dependable debugging partner that helps developers write safer, cleaner code, with evidence behind every finding and every fix.

Built With

  • ai-agents
  • api
  • artificial-intelligence
  • ast
  • automation
  • code-analysis
  • code-review
  • debugging
  • developer-tools
  • fastapi
  • generative-ai
  • git
  • github
  • llm
  • machine-learning
  • open-source
  • productivity
  • python
  • react
  • rest
  • security
  • software-engineering
  • static-analysis
  • tailwind-css
  • typescript
Share this project:

Updates

Submission history