We train your team on your codebase — not toy examples.
The goal is internal capability, not a permanent vendor. Transformations that stop the day the consultants leave are the failure mode we’re built against — so the Academy is designed to make your own people the ones who run the system after us.
Before Day 1, we remove one module from your repo.
Then your team rebuilds it — live, from spec, during training. Real code, real dependencies, real consequences. That's the whole method in one exercise.
One module comes out
We pick a real module from your own repo and remove it. Not a sample project. Not a tutorial app. A piece of the system your team ships every day.
Every developer freezes a baseline
Each developer estimates and records how long the rebuild would take them the old way — their personal pre-AI baseline, frozen before any AI touches the work.
Measured against yourself
The team rebuilds the module from spec, with the full working method — specs, memory, review gates. At Demo Day, every developer measures the result against their own frozen baseline. No vendor benchmark. Your number, against your number.
One for developers. One for everyone else.
For developers
The full working method, drilled on the code your team owns.
- Spec-driven work — write the spec before the prompt
- Review discipline — reading and gating AI-written changes
- Blast-radius judgment — what else does this change touch?
- Demo Day — the removed module rebuilt, measured against frozen baselines
For everyone else
The same discipline, applied to the repeatable work outside engineering.
- Reusable skills for repeatable work — built once, run every week
- Prototypes handed to product — ideas that arrive as working drafts
- Cost discipline across models — the right model for the job, not the biggest
Certification that cascades.
Your own engineers become the trainers, so capability spreads without us. Trained champions from your team run the system after we leave — that’s the design, not a risk.
Operator
Works the method daily: specs before prompts, changes through the gates, memory kept current. The baseline every cohort graduate reaches.
Practitioner
Owns the method for a repo or a team: seats the review roles, keeps the standards enforced, reads the scoreboard and acts on it.
Trainer
Runs the next cohort inside your company. From here, new hires and new teams are trained by your people — not by us.
Nine rungs. Each with an exit you can measure.
The Academy is rung zero of a bigger sequence. Every rung has a plain definition of done — you always know where you are, and what evidence gets you to the next one.
| Rung | Name | What happens | Measurable exit |
|---|---|---|---|
| Installed with our people in the room | |||
| L0 | Training | Academy cohort on your own codebase; every developer freezes a personal pre-AI baseline. | ✓ Whole cohort completes · baselines frozen · developers using AI tools daily |
| L1 | Discovery | Inventory the codebase; rank the risky and heavily-changed modules; capture the knowledge that lives in a few heads. | ✓ Inventory and risk register committed to the repo · module owners named |
| L2 | Memory & docs installed | Timo Docs and Timo Memory stamped into the repos — every claim cited to the code or flagged as a gap. | ✓ Conformance gate green in CI · a cited memory note per active module · token spend per task down vs the L0 baseline |
| L3 | Spec-first delivery | All work flows one way: issue → spec → AI session → pull request. The spec comes before the code, every time. | ✓ ≥90% of merged PRs trace to an issue · spec coverage rising |
| L4 | The scoreboard | Metrics connected across your tracker, GitHub, CI, and AI spend. Baselines frozen here — before we claim anything. | ✓ All metrics reporting weekly · every metric has a baseline, target, owner, and next action |
| L5 | Gates enforced | Timo Gates turned on for critical repos; review roles seated inside your team; secret-leak checks on everything generated. | ✓ Review coverage >90% on critical repos · first-attempt gate pass rate trending to target · zero secrets in generated artifacts |
| Run by your team, on the platform | |||
| L6 | Spec-driven by default | Spec-first becomes how new features ship, not a rule to remember. Your team's skill library and blueprints in daily use. | ✓ Majority of new features shipped spec-first · rework rate falling |
| L7 | Agents carry more of the work | A strong model plans, a cheaper model executes, a checker verifies — and your people hold the gates and the accountability. | ✓ AI-carried share of tasks rising while failure rate stays flat or falls · cost per shipped feature falling |
| L8 | The system runs itself | Gates hardened into CI; the scoreboard produces the board pack on its own; compliance evidence generated as a by-product of shipping. | ✓ Delivery metrics hold without our people present · evidence exported per release · cost per accepted outcome falling across quarters |
Honest scope note:the ladder is proven in legacy-enterprise engagements — large, older codebases with teams of specialists around them. We haven’t proven it everywhere, and we say so, because we’d rather under-claim.
Two of our people work inside your team.
Not a training company that visits and leaves a PDF. The pair stays through the rungs, works in your repos, and hands over on evidence.
An engineer
Works in your repos alongside your developers. Installs the memory and docs, runs the drills on real tickets, sits in the reviews until your people hold the gates themselves.
A program lead
Runs the cohorts, the cadence, and the scoreboard. Owns the exit evidence for each rung and reports it the same way to your team and your leadership.
The program runs a quarter at a time, with measurable exits. Every month, your engineering organization gets more AI-native.
“The gap between output produced and output understood is the single biggest risk to a codebase right now.”
“Every metric has a baseline, a target, an owner, and a next action. No self-reported KPIs.”
See where your codebase stands first.
The free Agent-Readiness Scan gives you a Readiness Score before you commit anyone's calendar to a cohort.