Enter the access code to continue.
How the team uses Claude to run client work — without you being the only person who can update anything. Two locked lanes, one clear wall between them.
The model in one line
Everything splits into two vaults. You hold the key to both. The team holds the key to one. The wall between them isn't a rule people have to remember — it's enforced by GitHub, so the team can't see the business side even if they tried.
Your business, your apps, your finances, your £40k mission — plus everything the team touches. Nothing is hidden from you.
Client delivery work — content, emails, campaigns. They never see business internals, finances or your personal strategy.
The full process · start to finish
The whole journey, top to bottom — from a team member logging in, through building client work, to it landing on your desk for sign-off. Every step is tracked.
Open claude.ai/code in a browser → sign in (their own Claude account) → connect GitHub → the Team Vault appears. No installs. They land in the team workspace only.
✎ Captured: who logged in + the exact timeClaude reads the team brain + that person's own file — so it works the Attain way, as them, on their clients. Not your mission, theirs.
Open clients/<name>/ — or spin up a brand-new client from a template.
They prompt Claude; it builds and edits inside that client's folder — emails, ad scripts, content, pages.
Work sits on their own branch → commit → push. Main stays locked, so nothing they do can break the source of truth.
You see it all in one private portal — live activity, what's been completed, and the queue of work flagged for review. Verify any claim by its timestamp.
The structure behind it
Read it top to bottom: who logs in → which vault they land in → what's inside.
The part most people miss
The system's power comes from context — but your context isn't the team's context. Yours is built around your mission and your numbers. A team member's Claude should think like someone delivering excellent client work, not like you. So context splits with the vaults, and each person layers their own on top.
Because context, data and inputs all live inside the Team Vault repo, every team member pulls the latest straight from GitHub — no copying files around, no "which version is right?". Update it once, everyone gets it on next pull.
How a team member actually works
Where everything gets updated
| Type of work | Lives in | Who updates it |
|---|---|---|
| Client welcome emails, sequences | Team Vault → clients/<name>/email | Team |
| Client ad scripts, campaigns, content | Team Vault → clients/<name>/marketing | Team |
| Brand voice, SOPs, quality bar | Team Vault → context/ | Team (you set the rules) |
| A new client onboarded | Team Vault → clients/ (from template) | Team |
| Live apps, portals, client dashboards | Business Vault → the app repos | You |
| Finances, strategy, your mission, deploy keys | Business Vault → context/ & data/ | You |
The safety rails
Nothing breaks · nothing gets lost
The team gets full reign to build — precisely because every change is tracked, attributed and reversible. If someone deletes the wrong thing, causes a conflict, drifts off-track, or acts badly, you can find exactly what happened, who did it, and what they typed — then roll it straight back. Four layers make that true.
Every edit is a saved snapshot. Any file, any version, any moment in time is recoverable — nothing is ever truly deleted.
The team builds on their own branches and changes merge in via review. The main record is locked — no one can force-overwrite or wipe history, even deliberately.
Every change is stamped with who and when. A built-in audit hook also logs the actual prompt each person typed and what Claude changed — so a breakage traces back to the exact instruction and person.
GitHub holds an off-site copy of everything; a nightly mirror adds a second. Every live deploy is snapshotted too — one click rolls back anything that went out.
| What happened | What you do | Result |
|---|---|---|
| A file or folder deleted by mistake | Restore it from history | Back in seconds — it was never gone |
| A change broke another project | Revert that one commit | Main restored, everything else untouched |
| "Who caused this — and how?" | Read the audit + prompt log at that time | The person, the timestamp, the exact prompt |
| A bad version went live | Roll back the deploy in one click | Previous good version live instantly |
| Someone acting harmfully | Revoke their access — their work sat on a branch | Main never at risk; every action on record |
The strongest protections — locked main, off-site copies, deploy rollback — live on GitHub & Vercel, outside any one person's machine. No team member can bypass, edit or erase them.
Your oversight portal
A separate, owner-only portal that turns the audit trail into something you can actually read. Every prompt, every change, every completion — in one place. The team never sees it; they just work, you see all of it.
A live feed of who prompted what and when. Filter by person, client or date.
When someone finishes, they type attain-complete — it lands here for the record.
attain-review flags work for your eyes. Approve or send back with notes.
"They said it's done." Check the timestamp — see exactly when it happened, or that it didn't.
Two markers the team learns — that's it: attain-complete when a task is done, attain-review when it's ready for you. Everything else is captured automatically.
A working preview (sample data) is built — ask Tom for the link. It runs behind your own login, separate from anything the team can reach.
How we build it — in order
Attain Digital · Operating structure · a living document — refine as the team grows.