53d North / AI Engineering
Services  /  AI Code Audit

AI Code Audit: Know what you own before you decide its future.

An AI Code Audit gives you an independent, evidence-based view of an existing software system: how secure it is, how well it's built, what it would take to keep running, and where the risks are. Our Code Factory sweeps every line. Then our engineers verify what matters and turn it into a long-term support plan you can act on.

8Audit lenses, from security to how much is documented
100%Of the codebase swept, not a sample
EverySerious finding checked by an engineer before it reaches you
1Support recommendation, presented in person

Who it's for: You rely on software you can't fully see into.

Most businesses we meet are running at least one system nobody fully understands any more. Before deciding whether to keep it, fix it, rebuild it or hand it to a new support partner, you need to know what's really inside.

“The agency that built it has gone.”

You've inherited a system with no one left who knows how it works.

“It started as a prototype.”

Something built fast, maybe with AI coding tools, is now running real parts of the business.

“Nobody wants to touch it.”

A legacy system that works, until it doesn't, and every change feels risky.

“We're buying, selling or raising.”

Technical due diligence before an acquisition, an investment or a large customer contract.

“We need a support partner.”

You want an honest scope of support, so you can compare partners fairly, including us.

How the audit runs: Machine sweep. Human judgement.

Agents give the audit its breadth, and engineers give it its depth. The gates in green are where our people do the work no tool can.

  1. 01

    Scope and access

    We agree what's in scope, sign an NDA and get read-only access to the code. We don't need your production data, and we'll tell you if a finding means we should look at how live data is handled.

    Kick-off with your teamRead-only access
  2. 02

    Full machine sweep

    Code Factory reviewers read the whole repository cold, alongside deterministic quality and security scanners, a dependency and licence audit, a secrets scan and an attempt to build and test from scratch.

    Security reviewerQuality reviewerScanners
  3. 03

    Map the system

    Agents map the architecture, the integrations, the data flows and where personal data lives. The documentation agent drafts an architecture overview that most inherited systems have never had.

    Analyst agentDocumentation agent
  4. 04

    Engineer deep-dive

    Our engineers check every serious finding by hand, throw out false positives, and judge the real risk in the context of your business. They also talk to the people who run and use the system.

    Senior engineer reviewInterviews with your team
  5. 05

    Recommend

    We prioritise the fixes, estimate the effort and recommend a long-term support approach, with a 12-month roadmap and the costs set out.

    Engineer + DPO sign-off
  6. 06

    Readout

    We present the findings to your leadership team in person, take the hard questions, and leave you with everything you need to decide, whoever you choose to support it.

    Presented in person

Eight audit lenses: What we look at, and who looks.

For every lens, agents do the exhaustive checking and engineers make the judgement calls. Select a lens to see the split.

Security

Can it be broken into, and what would an attacker get?

Code Factory checks
  • Injection, access control, sessions, XSS and SSRF
  • Secrets committed to the code or its history
  • Weak or outdated cryptography
  • Findings mapped to CWE and OWASP Top 10
Our engineers judge
  • Which findings are actually exploitable in your set-up
  • Which risks to fix now, and which to accept
  • Whether a penetration test is warranted

Data protection

Where personal data lives, and whether it's handled lawfully.

Code Factory checks
  • Where personal data is stored, logged and sent
  • Retention, deletion and data export routes
  • Third-party services that receive personal data
  • Mapping to UK GDPR articles
Our engineers judge
  • Lawful basis and data minimisation in context
  • What your records of processing should say
  • Reviewed by our CTO, who is our named Data Protection Officer

Code quality

How easy it will be to change safely.

Code Factory checks
  • Complexity, duplication and dead code
  • Error handling and input validation
  • Consistency with the framework's conventions
  • Deterministic quality scoring on every file
Our engineers judge
  • Whether the design will bear the changes you're planning
  • Which areas are fragile and which are fine
  • What "good enough" means for a system like yours

Tests & reliability

Whether you can change it without breaking it.

Code Factory checks
  • Whether the project builds and runs from scratch
  • Test coverage and what the tests really check
  • Flaky or disabled tests
  • Gaps against the most-used user journeys
Our engineers judge
  • Which journeys are business-critical
  • Where tests would pay back fastest
  • How much risk each release really carries

Dependencies

What it's built on, and whether that's still supported.

Code Factory checks
  • Every library and framework version
  • Known vulnerabilities and end-of-life components
  • Licence obligations and conflicts
  • Supply-chain risk signals
Our engineers judge
  • Upgrade paths and how much effort each takes
  • Which upgrades can wait and which can't
  • Whether a component should be replaced

Architecture

How it fits together, and whether it will scale.

Code Factory checks
  • A map of components, integrations and data flows
  • Coupling and single points of failure
  • Performance hot spots in the code
  • Infrastructure and hosting configuration
Our engineers judge
  • Whether the architecture fits where the business is going
  • Build-versus-buy for the weakest components
  • Where AI could add value later

Operations

How it's deployed, watched and recovered.

Code Factory checks
  • Build and deployment pipeline
  • Logging, monitoring and alerting
  • Backup and restore configuration
  • Environment and secrets management
Our engineers judge
  • Whether recovery would actually work on a bad day
  • What a realistic support rota looks like
  • Interviews with whoever keeps it running today

Knowledge

How much of the system lives only in someone's head.

Code Factory checks
  • Existing documentation and how current it is
  • Comment and naming quality
  • Who changed what, and how concentrated knowledge is
  • A drafted architecture overview
Our engineers judge
  • How dependent you are on any one person
  • What has to be written down first
  • A handover plan to whoever supports it next

Signal, not noise: Hundreds of alerts in. The few that matter out.

Automated tools on their own produce long lists that nobody reads. The value of an audit is in the filtering: knowing which findings are real, which matter to your business, and which to fix first.

Example audit
Raw machine findingsEvery reviewer and scanner, combined
412
After de-duplicationSame issue, many places, counted once
214
Verified by engineersFalse positives removed, real risk judged
83
Priority actionsWhat to fix first, and why
12

Illustrative figures for a typical mid-sized business application

What the report looks like: Clear enough for the board. Detailed enough for engineers.

Customer portal · audit summary

Example report · illustrative
RecommendationStabilise, then modernise in place. The core is sound. Fix three high risks within 30 days, then move to a co-run support model.
Security● Needs attention
Data protection▲ At risk
Code quality✓ Sound
Tests and reliability● Needs attention
Dependencies▲ At risk
Architecture✓ Sound
Operations● Needs attention
Knowledge and documentation▲ At risk
Top priorities
1
Customer data kept in logs indefinitelyPersonal data in application logs with no retention limit. UK GDPR storage-limitation risk.
2
Framework version past end of lifeNo more security patches. Upgrade path mapped, roughly two weeks of effort.
3
Admin area lacks rate limitingLogin open to password-guessing attacks. A small fix with a big reduction in risk.
4
One person understands deploymentsNo runbook and no rollback plan. Documented as part of the audit, then rehearsed.

Long-term support: Four paths. One honest recommendation.

Every audit ends with a recommendation on what to do with the system over the next one to three years, backed by the evidence, with the effort and running costs set out for each path.

Path 1

Stabilise & support

Keep the system as it is. Fix the priority risks, document it properly and put a support arrangement around it.

Right whenThe core is sound and the system meets the business need
Path 2

Modernise in place

Improve it step by step through the Code Factory: upgrades, refactoring and tests added, with the system staying live throughout.

Right whenThe foundations are reasonable but the system is ageing
Path 3

Rebuild selectively

Replace the parts that are beyond saving, keep the rest, and migrate safely between the two.

Right whenSpecific components carry most of the risk or cost
Path 4

Retire or replace

Move to an off-the-shelf product or a platform you already pay for, with a migration plan for your data.

Right whenThe system no longer gives you an edge worth maintaining

Whichever path you take, we lay out the support options in plain terms: managed by us, co-run with your team, or a full handover to your people or another partner. See how these work on our Scale page.

What you receive: Everything you need, whoever supports it next.

Executive summary

A health rating for each lens, the verdict and the top priorities, on a few pages your board will actually read.

Findings register

Every verified finding with evidence, severity, fix and compliance mapping, exported to your issue tracker.

Architecture map

How the system fits together: components, integrations, data flows and where personal data lives.

Security and data protection summary

Written to help you answer customer security questionnaires and to feed your data protection impact assessment.

12-month support roadmap

The recommended path, sequenced by priority, with the effort and indicative costs for each stage.

Runbook starter pack

How to build, deploy and roll back the system, written down, often for the first time.

Our promise: Independent, even when it's not in our interest.

Honest verdicts

We'll say when it's good

If your system is in better shape than you feared, we'll tell you, and we won't invent work to fill a roadmap.

Partner-neutral

Yours to take anywhere

The report, findings and runbooks are yours. Use them with us, with your own team or with another partner.

No blame

About the system, not the people

Most problems come from deadlines and budgets, not bad engineers. We write reports your current team can stand behind.

Questions · AI Code Audit

Common questions about the AI Code Audit.

What access do you need for an audit?

Read-only access to the code, under an NDA. We don't need your production data.

What does the audit cover?

Eight lenses: security, data protection, code quality, tests and reliability, dependencies, architecture, operations, and knowledge, meaning how much of the system lives only in someone's head.

Can you audit software built with AI coding tools?

Yes. Prototypes built quickly with AI coding tools that are now running real parts of a business are one of the most common reasons clients ask for an audit.

Will you just recommend that we hire you?

No. The recommendation is whatever's right for your system, including retiring it. The report, findings and runbooks are yours to use with any partner.

What do we receive?

An executive summary, a findings register for your issue tracker, an architecture map, a security and data protection summary, a 12-month support roadmap and a runbook starter pack.

Next step: Find out what's really in there.

Tell us about the system and what's prompting the question. We'll come back with a scope, a timeline and a fixed price for the audit.