Onboarding
Every new hire spends their first fortnight re-explaining the codebase to an assistant that already forgot.
Your engineers adopted AI. Your engineering org didn't.
Shared context, shared skills, your own agents and your own rules — installed across the team in one commit, and running on a fraction of the tokens. Your source code never leaves the machine.
- Shared codebase context
- Shared skills and agents
- House rules, served per run
- Guardrails, not advice
- Release gates and verdicts
- Usage, cost and Developer productivity
- Team access and audit trail
- Security and privacy, intact
- 66–86%
- fewer tokens per runmeasured
- ~3×
- more work, same spendarithmetic, at 66%
What ungoverned AI actually costs you
Standards
Your engineering rules live in a document. No assistant on your team has ever read it.
Risk
Nothing sits between a confident assistant and your production branch except the developer's attention.
Spend
You find out what AI cost your team when the invoice arrives, with no idea which repo it went to.
We work one layer below the answer
Every prompt is classified locally before Claude sees it. Touch something your company has a rule about, and that rule rides along automatically.
- Developer typesupdate the payout balance logic
- Classified locallycode · touches money
- Your rule attachedAmounts stay strings end to end. Multi-table writes go in one transaction.
- Claude answersto your standards, first try — no review round-trip
Standardise. Enforce. Account for it.
Standardise
The same senior engineer, sitting with everyone.
The repo explains itself
ShipsuitAI generates a guide to your codebase and commits it — new hires inherit it from git, and so does their assistant, on day one.
One workflow, installed everywhere
A single committed settings block puts the same workflow on every machine. Nobody configures anything themselves.
Your specialists, defined once
Your review agents are defined centrally and served per run. Update one, and every developer gets the update.
Change a rule once
Engineering rules are versioned and served fresh on every run — no pull request to twenty codebases.
Enforce
Enforcement, not advice.
Hard stops, not suggestions
Nothing commits or pushes without approval, no database commands run, and prompts are nudged toward your rules before work starts.
Stopped before the pull request exists
Quality gates plus a house-rules review resolve to one verdict — unfinished work never reaches a reviewer's queue.
Account for it
Know what it costs, who has it, and what changed.
Developer productivity
Sessions, commits, lines shipped and the accepted-edit rate — per person, using the assistant's own reported activity.
Usage & cost
What your AI assistant actually cost, per developer and repository — the assistant's own numbers, not estimates.
Team & access
Seats, roles and per-developer credentials, revoked individually — plus account-level suspend and resume.
Audit trail
Every administrative action, recorded append-only. The record survives even the deletion of the thing it describes.
Three steps. Then it runs itself.
01
We encode your way of working
Your house rules, review checklist and specialist agents become a served bundle — none of it lands on a developer's disk.
02
Your lead runs one command
The plugin installs itself and the settings get committed. Every clone and every new hire inherits it from git.
03
It runs on every session
Context on the first prompt, your rules on every answer, a gate before anything ships — plus a usage picture leadership can act on.
Privacy
Your source code stays on the laptop
ShipsuitAI never uploads your repository. Every byte that leaves goes through one auditable channel — the same one you can hand your security team.
- Developer machinerepository · keys · file paths
- One channelcounts · durations · versions
- ShipsuitAIrules · metering
everything that leaves
Enforced by design, not by policy
Not a policy — a property of the design. Every check runs locally, and your source code never leaves the machine.
Enforced by schema, not by promise
The ingest boundary is an allowlist. A field we haven't named cannot be stored, however the payload changes.
Your source code never leaves
Reviews run against your code locally and send back findings, never the code itself.
Metadata only, and we list it
Counts, durations, model names, versions. No source, no file paths.
Isolated per company, proven
Every query is scoped by company at a single choke point — a test suite that must stay green proves it.
Per-developer tokens
Each person gets their own credential. Offboarding someone kills their access alone.
Your rules stay yours
Licensed rulesets are served per run and never written to a developer's disk.
An audit trail that outlives its subject
Every administrative action, recorded append-only. Entries survive even the deletion of the account they describe.
The four questions we always get
- “Will this slow my senior engineers down?”
- Nothing changes mid-task. The only interruption is at the gate — an approval before code commits or pushes, and one verdict before a pull request.
- “What exactly leaves our machines?”
- Your source code never leaves the machine — enforced by an allowlist at the ingest boundary, not by policy. Never the repository, never a file path.
- “What happens if we stop paying?”
- The repo guide and the settings block are ordinary files already committed to your repositories. They stay. The served rulesets and agents leave with the subscription.
- “How long until the whole team is on it?”
- One settings block per repository, and each developer picks it up on their next run. No rollout, no installers, no per-machine setup.
Your team is already paying for Claude Code
The question is whether it works like your company. Onboard one repo and compare a week against the week before.