// METHODOLOGY
Staged, traceable, transparent.
The principle: first cheap, objective facts — only then expensive AI. Every stage records its evidence. The result is a traceable audit log, not a black-box score.
// STAGE A · ANTI-FRAUD
Ghostwriter detector
Forensic .git analysis with LibGit2Sharp over up to 200 commits: what share of the changed lines falls to the most frequent author, and whether a single commit brought most of the code at once (a code dump). Plain C#, no AI costs. It measures how the authorship is spread, not who submits the repository. It also names the commit it checked and the AI share: how many commits themselves state an AI agent's part (co-author trailers, a “Generated with” line, agent accounts such as Copilot or Claude). That is a share, not a judgement and no deduction; the check does not see AI use that leaves no mark, and it never claims “AI-free”. It asks the host’s public API whether the repository is a fork and of what; for a fork it counts only the commits after the fork point (the commits up to it are the original’s): GitHub and GitLab name it through their comparison with the original, on Codeberg the check asks the original for commits of the clone, Bitbucket names none, and then every commit counts. A repository its host does not mark as a fork is looked up by its oldest commit in GitHub’s commit search: if an older repository has the same history, the result says “same Git history, without a fork mark” and stage A treats it like a fork of that repository; found only in younger ones, it is a hint without a deduction. If the host or the search does not answer, the result says so and nothing is deducted. A copy with a rewritten history, on another host or in a fork is not found this way. Copied code without its history: the check compares the source files (without tests, vendored, generated and minified code; the largest) by fingerprints of their tokens with the earlier public checks at Acquispect whose result is shown; renamed and reformatted files count as the same. The result names how many files match an earlier check of which repository, with its run: a hint without a deduction. Only against earlier checks at Acquispect, no index of the whole web: code from elsewhere is not seen this way. A hidden or erased result is compared with nothing from then on, and checks of company accounts never enter the index.
// STAGE B · HYGIENE
Safety Check
Patterns of leaked secrets in the working tree and in the history: the public key formats of GitHub, AWS, Azure (storage keys, SAS tokens), Entra client secrets, Google, Stripe live keys, Slack, npm and PyPI, private key headers, and keys and passwords assigned in plain text. A found value is never shown and never tried against the provider. Weak cryptography and Process.Start in C# (Roslyn), test files by their names and the tech stack by file extensions. Also the dependencies, checked against known vulnerabilities: the check reads lock and manifest files (npm, NuGet, Cargo, Go, Bundler, Composer, pip, Poetry, Maven, Gradle, Pub, Hex, Swift) as text only, without building or installing anything, asks OSV.dev (which includes the GitHub Advisory Database) about the package names and exact versions, and reads each advisory's entry for its severity, one entry of every affected package before any package gets a second: the CVSS 3.x base score where the entry has such a vector, else the CVSS 4.0 score by FIRST's specification, else the GitHub Advisory Database's rating; where an entry names none, that of an alias of the same vulnerability (a GHSA id, else a CVE id) counts. What is not read within the time limit counts as unknown, and the audit log says how many entries were read. Each vulnerable package costs points by the worst of its vulnerabilities: critical 10, high 7, medium 4, low 2, unknown severity 5; at most 25 in all. Whether the code reaches the flaw is not assessed. Without points, the check also says at import level whether a source file outside the tests imports an affected package ("imported"), whether the lock file lists it as a direct dependency or it comes only through another package (package-lock.json version 2 or later, Cargo.lock, go.mod): for npm, Go and Cargo, where the package name is the import name; for PyPI, Maven, NuGet, Composer and the others it says "not checkable", without a guessed mapping. That is no call graph: it does not say whether the affected code runs. If OSV.dev cannot be reached or there is no lock file, the audit log says so and nothing is claimed. The check does not measure test coverage, because it never runs other people's code.
For TypeScript/JavaScript, Python, Java/Kotlin and Go, a reader of its own per language family reads the code as text; comments and strings do not count, and nothing is run. It looks for injection (eval, SQL built from strings, also through a variable set shortly before, HTML from values), weak cryptography and switched-off certificate checks, unsafe deserialization (such as pickle, ObjectInputStream, yaml.load without a safe loader) and starting other programs, in at most 400 files per language and without test files, vendored and minified code. Each finding costs 5 points like a risky C# call, at most 30 together. A finding is a risky call at that place, not a proven vulnerability: the rules do not trace where a value comes from. The tech stack names each language with its share of the non-empty source lines (without generated and vendored code) and the frameworks that dependency files and project SDKs name.
Without points, because they say more about the project than about the person, signals after the openly documented checks of the OpenSSF Scorecard stand beside them: whether actions are pinned by commit hash and base images by digest and whether a script is downloaded and run at once, dangerous workflow patterns (a pull request's code under pull_request_target, values like an issue's title in run scripts), the workflows' token rights and static analysis in the workflows. Through the public API of GitHub and GitLab, without signing in and without running anything: the CI results of the checked commit, the visible protection of the checked branch, on GitHub the share of merged pull requests approved by a review since the oldest of the last 30 commits, and signed releases (among the attached files of the last five releases a signature or provenance file by the Scorecard's file endings; the check does not verify the signatures, and no releases is no minus). If the host does not answer or its request limit is reached, the audit log says “not checked”; for other hosts the check does not read these signals. For every host the upkeep after Scorecard “Maintained”: the commits of the last 90 days from the clone (if its 200 commits do not reach back that far, it says “at least”) and, according to the host's answer, whether the repository is archived or younger than 90 days.
On /scan a branch (otherwise the default branch) and, for a monorepo, a subfolder can be given. With a subfolder only its files and the commits that change it count in stages A and B; workflows, the CI result, branch protection and code review are the whole repository's, and the result names the folder.
// STAGE C · AI PANEL
Panel of Experts
Five AI personas (tech lead, security, performance, architecture, craft) each assess an excerpt of the code on their own, each with a score from 0 to 100 and one sentence that stands in the result. The panel is a language model on Microsoft Azure, not human reviewers. Every check first asks whether the panel's monthly budget still allows it. If a persona gives no answer or the budget is used up, the check runs without Stage C, the result says “Expert panel not available”, and no Stage C counts in the verdict. The same model writes five questions about places in the submitted code (“Defend your repo”): whoever started the check answers them in writing, the model judges the answers against the excerpt of each file (statements about code outside the excerpt cannot be checked there: it names them apart, and they count neither for nor against the answer), and the result stands beside the verdict without changing it. It proves no authorship.
// THE VERDICT
How the recommendation comes about
With the expert panel, Stages A and B count for 40 % and the panel for 60 %: “Strong Hire” from 85, “Hire” from 70, “Lean” from 50, “No Hire” below. Without the panel the confidence score is the mean of Stages A and B, and the recommendation goes no higher than “Lean”: “Hire” and “Strong Hire” say something about the quality of the code, which Stages A and B do not read. The “Verified by Acquispect” badge is only for “Hire” and “Strong Hire”. The verdict is about the repository, not about the person who submits it.
// THE CREDENTIAL
Checkable with the public key, without asking us
Every finished check is signed as a W3C Verifiable Credential (VC-JWT, ES256, issuer did:web:acquispect.com): the recommendation with its confidence score, the findings of Stages A and B and the checked repository with its commit; the panel's opinions (Stage C) are in the public verification, not in the credential. The private key lives in Azure Key Vault and never leaves it; the public key is in the did:web document at /.well-known/did.json. The public verification offers the credential to download. It is issued to the random identifier of the session that started the check and names no person; binding it to the person who wrote the code is planned.
// ORCHESTRATION
One grain per audit — instead of a message broker.
The pipeline runs in a Microsoft Orleans grain: one activation per audit, one step after the other, in the background, while the page asks for the stages as soon as they are done. A check takes five minutes at most. The result is stored by event sourcing (Eventuous) step by step: the start, the commit that was read, every stage and the verdict. A check that a restart of the site interrupts is picked up again once: it clones the repository anew and runs only the stages still missing (all of them if the repository has a new commit by then); interrupted a second time, it has to be started again. No RabbitMQ, no zoo of services: a modular monolith on .NET 10 and Aspire.