Confidence before edits

ReadyBase is two planes, one mission: Prefex rows cheaper, ReadyBase steers smarter.

AI-Readiness Score

A clear 0-100 grade for how safely AI can work in your codebase, weighted by risk — not size — so a big, well-owned repo isn't punished and a fragile one can't hide. Every gap comes with the exact fix that raises it.

Quality Hotspots

Pinpoint the riskiest files so cleanup starts where it matters most.

Context navigation

Ask structural questions: what depends on this file, what changed here, where should I start?

Blast-radius warnings

Warns before a risky change, stops AI from breaking things it didn't know it touched.

Coherence & drift

Learns your repo's conventions and flags vibe drift — AI output that compiles and passes review but doesn't match how your team actually builds.

Readiness Certificate

A one-page, manager-facing verdict: is this repo AI-safe yet, and what's left to fix?

Portfolio + Trend

Rank every repo by readiness and watch the numbers improve over time.

Claude Code integration

Plugs into your AI assistant invisibly, context and warnings arrive at the right moment.

Local dashboard

A browser view for scores, gaps, and codebase health, no terminal needed.

Autonomy ladder

Four levels, L0 to L3, that say how far an agent may run on this repo. Each level is gated on evidence, not opinion: unresolved structural drift, gaps in the protected-file list, or missing cost telemetry hold a repo back until they are fixed.

Enforced edit guard

Opt a repo into agent mode and the guard stops refusing politely. An edit to a protected file is rejected before it happens. A human clears one file at a time, with an approval that expires on its own.

Reachability & taint

Traces which request handlers can actually reach a process-execution or outbound-network call, and whether user input reaches it unsanitised along the way. Call-graph precision, no JVM, no sidecar.

AI provenance

How much of each file was written by an agent, and whether one human has ever reviewed it. The answer to "who owns it when the AI breaks something", derived from git rather than asserted.

The thesis

AI writes code faster than it can understand yours.

Understanding the codebase is the first thing a new engineer does, and the one thing your AI skips. The context that keeps changes safe lives in senior engineers' heads, and the agent never gets the handoff.

The confident stranger

It edits like it read the whole repo. It didn't, and it can't see which file is load-bearing, so it changes the one with 37 dependents as casually as a typo fix.

Tribal knowledge doesn't travel

"Don't touch that without asking Maria" lives in Slack and in Maria's head. The agent never got the memo, and Maria's on vacation.

You find out in production

A context-free edit looks clean in the diff. The blast radius only shows up when the pager goes off. Review caught the syntax, not the systemic risk.

A ship deck looking out to open sea, with no chart or compass anywhere on it

BeforeSailing blind. The same deck, no chart and no compass to steer by.

→

The same deck, now with a chart unrolled and a compass set out, ready to navigate

AfterChart on the table, compass in hand. Every edit on a known course.

The answer was never a smarter model. It was a foundation: map the codebase, guard the dangerous edits, and prove control while the work is happening.

The foundation

Map. Guard. Govern.

The same three layers that sit under Prefex, pointed at a different plane. Prefex measures, auto-applies, and coaches your spend. ReadyBase does the same for your code's safety.

01 · Map

One scan builds the dependency graph, co-change history, ownership, and complexity map of your repo. You can't guard what you haven't mapped.

02 · Guard

Rules and context inject themselves into the AI session. No prompt engineering, no workflow change. For a human it stays advisory; for an agent it can refuse the edit outright. The danger zones defend themselves.

03 · Govern

Blast-radius warnings in the moment, a readiness score over time, a one-page certificate for leadership, and an autonomy ladder that says how far an agent may run unattended. A risk you see before you commit changes what you commit.

How we build it

The same three non-negotiables.

1 · Fail open

A ReadyBase error never blocks your work. On bad input or a slow path, it logs and gets out of the way. The guard is never a single point of failure.

2 · Binary, not source

One CGO-free Go binary. No runtime, no sidecar to supervise, no service phoning home. It reads your repo on disk and writes plain files you can diff.

3 · Your code stays home

Everything runs on localhost, against your own git history. No telemetry, no upload, no third party in the loop. See the privacy details →

Lineage: ideas we learned from, rebuilt native.

We study the sharpest ideas in code intelligence, extract the intuition, and re-author it local-first inside our own principles.

Dependency graphs → blast-radius analysis CODEOWNERS → ownership & bus factor Truck-factor research → knowledge-risk scoring Quality gates → the readiness score Co-change mining → hidden coupling AGENTS.md / context files → auto-generated guidance

The second axis

Readiness gets AI in. Coherence keeps it on your rails.

ReadyBase attaches the smallest, most relevant context to every AI turn — keeping sessions grounded in your actual codebase, not hallucinated assumptions — while quietly watching for vibe drift: AI output that works, but doesn't fit how your team actually builds.

Context per turn, not per repo

Not the whole codebase dumped into the prompt. For each turn, the smallest slice that matters — the dependents, the owners, the recent churn around what's being touched — so the model stays grounded and you don't pay for noise.

It learns your conventions

From the AST and git history, ReadyBase infers how you build — naming, structure, error handling, test shape — by consensus, not a style guide nobody reads. That baseline is what drift is measured against.

Drift, caught in the moment

Code that compiles and passes review can still be subtly off-house-style. Coherence surfaces it as it happens — not three months and a thousand copy-paste lines later, when it's the new normal.

Two axes, one binary: readiness tells you if AI can work here safely, coherence tells you whether what it wrote belongs.

See it

The readiness console, on your own machine.

One score, and a ranked punch list of what to fix next, ordered by points-per-hour so the cheapest wins come first. No dashboards to host, no code leaves your laptop.

readybase · localhost:8765

ReadyBase console showing recommended next actions ranked by points-per-hour, each with point gain, time estimate, and ROI

Early Access

The install commands unlock the moment you join. Ships with a 60-day Pro trial that activates on first run — offline, no credit card, no obligation.

One command to AI-ready

ReadyBase is a single, static binary, no dependencies, no runtime, no server. Runs entirely on your machine.

macOS / Linux

Windows

Download

Bash

curl -fsSL https://promptforce.ai/rb-install.sh | bash

PowerShell

iwr https://promptforce.ai/rb-install.ps1 -OutFile rb-install.ps1; .\rb-install.ps1

Direct download (any platform)

github.com/PromptForcePrime/readybase-public/releases

First command

readybase go .

This runs everything: scan, setup, index, probe, benchmark. You're AI-ready in seconds.

What changes

Your AI behaves smarter

No more re-explaining the repo. The assistant knows the structure, conventions, and danger zones from the start.

Fewer broken deployments

Blast-radius warnings stop careless edits before they hit production. High-risk files get careful treatment.

Leadership gets a scorecard

One number per repo, rankings across the org, and proof the readiness investment is working.

Code stays private

Everything runs locally on your machine, no code is uploaded, no third party sees your source.