AquilaX Code Quality finds the problems that make code hard to review and easy to break: complexity hotspots, copy-pasted logic, swallowed exceptions and resource leaks. It checks every pull request, scores each repository, and shows you which issues are most likely to turn into a real bug or vulnerability.
Numbers as of Q1 2026 — updated quarterly.
Style nits are easy to find and rarely matter. AquilaX focuses on the patterns that make code break in production or let a vulnerability slip through review.
Functions with high cyclomatic and cognitive complexity, deep nesting and long parameter lists. These are the places reviewers skim and tests miss.
Copy-pasted blocks across files and services. When one copy gets a fix and the others don't, you have a bug that's already been fixed once.
Swallowed exceptions, catch-all handlers, ignored return values and errors logged but never acted on. Failures that should stop a request let it carry on.
File handles, sockets and database connections that aren't released on every path, plus null dereferences. Under load these become outages.
Unused functions, unreachable branches and old feature flags. Dead code still ships, still gets scanned, and sometimes still has a route pointing at it.
An A–E grade for every repository and file, with the trend over time. See whether new code is making things better or worse, not just how big the backlog is.
Each of these passes the tests and looks reasonable in review. Then one failure mode later, it lets everyone in, ships an old rule, or takes the service down.
def can_access(user, doc):
try:
return acl.check(user.id, doc.id)
except Exception:
return True # don't block users if ACL is down
The comment explains the intent: keep people working if the ACL service hiccups. In practice, any timeout, bug or malformed ID now grants access to every document.
Catch-all handlers hide exactly this kind of decision. The scanner flags broad exception handlers on security-relevant paths, especially ones that return a success value.
except AclUnavailable:
log.warning("ACL check failed for %s", doc.id)
return False # fail closed; show a retry message
// routes/signup.js
if (!isEmail(body.email)) return bad(res);
if (body.password.length < 12) return bad(res);
// routes/invite-accept.js (copied from signup in 2023)
if (!isEmail(body.email)) return bad(res);
if (body.password.length < 6) return bad(res);
Someone raised the minimum password length to 12 in signup. The invite flow was a copy, so it kept the old rule, and invited users can still pick a 6-character password.
Duplicate detection finds blocks that started identical and then diverged, which is usually a fix applied to only one copy.
// lib/validate.js: one rule, used by both routes
export function validateCredentials(body) {
if (!isEmail(body.email)) return false;
return body.password.length >= PASSWORD_MIN;
}
public List<Order> recent(long userId) throws SQLException {
Connection c = dataSource.getConnection();
PreparedStatement ps = c.prepareStatement(
"SELECT * FROM orders WHERE user_id = ?");
ps.setLong(1, userId);
ResultSet rs = ps.executeQuery();
if (!rs.next()) return List.of(); // c is never closed
List<Order> out = map(rs);
c.close();
return out;
}
Every user with no orders leaks one pooled connection. With a pool of 20, the 21st new customer of the day hangs, and so does everyone after them.
That's a denial of service anyone can trigger by signing up. The scanner follows every exit path of a function and checks that acquired resources are released on all of them.
try (Connection c = dataSource.getConnection();
PreparedStatement ps = c.prepareStatement(SQL)) {
ps.setLong(1, userId);
try (ResultSet rs = ps.executeQuery()) {
return map(rs); // closed on every path
}
}
Nobody can fix ten years of debt in one sprint. AquilaX holds new code to the bar and tracks the rest, so quality gets better with every merge.
Builds the syntax tree and call graph for each file in the scan.
Complexity, duplication, error handling and resource use, per function and per file.
Securitron AI ranks issues by bug risk and puts the ones in your pull request first.
Findings appear on the PR, and the group security policy decides when a build fails.
Teams that already run SAST and want one place for security and maintainability, instead of a second tool and a second dashboard.
Assistants copy and paste instead of refactoring, and add a new helper instead of reusing the old one. Code Quality catches the duplication and growing complexity before they settle in.
See which services are getting harder to change, track the grade per sprint, and make the case for refactoring with numbers instead of gut feeling.
Swallowed errors and leaky resources are often where security bugs start. Seeing them next to SAST findings gives you the full picture in one dashboard.
Connect your GitHub, GitLab or Bitbucket repo. Code Quality runs alongside SAST on every push, with no extra setup.